Debian Codegraph @

lib/puppet_x/augeas/util/parser.rb

raw
1 # rubocop:disable Style/Documentation
2 module PuppetX; end
3 module PuppetX::Augeas; end
4 module PuppetX::Augeas::Util; end
5 # rubocop:enable Style/Documentation
6
7 # Container for helpers to parse user provided data contained in manifests.
8 module PuppetX::Augeas::Util::Parser
9 TOKEN_ARRAY_CLOSE = %r{\s*\]\s*}
10 TOKEN_ARRAY_OPEN = %r{\s*\[\s*}
11 TOKEN_ARRAY_SEPARATOR = %r{\s*,\s*}
12 TOKEN_CLOSE_CURLY = %r|}|
13 TOKEN_DOUBLE_QUOTE = %r{"}
14 TOKEN_DOUBLE_QUOTE_ESCAPED_CHAR = %r{\\(["\\abtnvfres0-7xu])}
15 TOKEN_DOUBLE_QUOTE_UNESCAPED_CHAR = %r{[^"\\]}
16 TOKEN_HEX_CHAR = %r{[0-9a-fA-F]{1,2}}
17 TOKEN_OCTAL_CHAR = %r{[0-7]{1,3}}
18 TOKEN_OPEN_CURLY = %r|{|
19 TOKEN_SINGLE_QUOTE = %r{'}
20 TOKEN_SINGLE_QUOTE_ESCAPED_CHAR = %r{\\(['\\])}
21 TOKEN_SINGLE_QUOTE_UNESCAPED_CHAR = %r{[^'\\]}
22 TOKEN_SPACE = %r{\s}
23 TOKEN_UNICODE_LONG_HEX_CHAR = %r{[0-9a-fA-F]{1,6}}
24 TOKEN_UNICODE_SHORT_HEX_CHAR = %r{[0-9a-fA-F]{4}}
25
26 # Parse a string into the (nearly) equivalent Ruby array. This only handles
27 # arrays with string members (double-, or single-quoted), and does not
28 # support the full quite of escape sequences that Ruby allows in
29 # double-quoted strings.
30 #
31 # @param [String] The string to be parsed.
32 # @return [Array<String>] The parsed array elements, including handling any
33 # escape sequences.
34 def parse_to_array(string)
35 s = StringScanner.new(string)
36 match = array_open(s)
37 raise "Unexpected character in array at: #{s.rest}" if match.nil?
38
39 array_content = array_values(s)
40
41 match = array_close(s)
42 raise "Unexpected character in array at: #{s.rest}" if match.nil? || !s.empty?
43
44 array_content
45 end
46
47 def array_open(scanner)
48 scanner.scan(TOKEN_ARRAY_OPEN)
49 end
50 private :array_open
51
52 def array_close(scanner)
53 scanner.scan(TOKEN_ARRAY_CLOSE)
54 end
55 private :array_close
56
57 def array_separator(scanner)
58 scanner.scan(TOKEN_ARRAY_SEPARATOR)
59 end
60 private :array_separator
61
62 def single_quote_unescaped_char(scanner)
63 scanner.scan(TOKEN_SINGLE_QUOTE_UNESCAPED_CHAR)
64 end
65 private :single_quote_unescaped_char
66
67 def single_quote_escaped_char(scanner)
68 scanner.scan(TOKEN_SINGLE_QUOTE_ESCAPED_CHAR) && scanner[1]
69 end
70 private :single_quote_escaped_char
71
72 def single_quote_char(scanner)
73 single_quote_escaped_char(scanner) || single_quote_unescaped_char(scanner)
74 end
75 private :single_quote_char
76
77 def double_quote_unescaped_char(scanner)
78 scanner.scan(TOKEN_DOUBLE_QUOTE_UNESCAPED_CHAR)
79 end
80 private :double_quote_unescaped_char
81
82 # This handles the possible Ruby escape sequences in double-quoted strings,
83 # except for \M-x, \M-\C-x, \M-\cx, \c\M-x, \c?, and \C-?. The full list of
84 # escape sequences, and their meanings is taken from:
85 # https://github.com/ruby/ruby/blob/90fdfec11a4a42653722e2ce2a672d6e87a57b8e/doc/syntax/literals.rdoc#strings
86 def double_quote_escaped_char(scanner)
87 match = scanner.scan(TOKEN_DOUBLE_QUOTE_ESCAPED_CHAR)
88 return nil if match.nil?
89
90 case scanner[1]
91 when '\\' then return '\\'
92 when '"' then return '"'
93 when 'a' then return "\a"
94 when 'b' then return "\b"
95 when 't' then return "\t"
96 when 'n' then return "\n"
97 when 'v' then return "\v"
98 when 'f' then return "\f"
99 when 'r' then return "\r"
100 when 'e' then return "\e"
101 when 's' then return "\s"
102 when %r{[0-7]}
103 # Back the scanner up by one byte so we can grab all of the potential
104 # octal digits at the same time.
105 scanner.pos = scanner.pos - 1
106 octal_character = scanner.scan(TOKEN_OCTAL_CHAR)
107
108 return octal_character.to_i(8).chr
109 when 'x'
110 hex_character = scanner.scan(TOKEN_HEX_CHAR)
111 return nil if hex_character.nil?
112
113 hex_character.to_i(16).chr
114 when 'u'
115 return unicode_short_hex_character(scanner) || unicode_long_hex_characters(scanner)
116 else
117 # Not a valid escape sequence as far as we're concerned.
118 return nil
119 end
120 end
121 private :double_quote_escaped_char
122
123 def unicode_short_hex_character(scanner)
124 unicode_character = scanner.scan(TOKEN_UNICODE_SHORT_HEX_CHAR)
125 return nil if unicode_character.nil?
126
127 [unicode_character.hex].pack 'U'
128 end
129 private :unicode_short_hex_character
130
131 def unicode_long_hex_characters(scanner)
132 unicode_string = ''
133 return nil unless scanner.scan(TOKEN_OPEN_CURLY)
134
135 loop do
136 char = scanner.scan(TOKEN_UNICODE_LONG_HEX_CHAR)
137 break if char.nil?
138 unicode_string << [char.hex].pack('U')
139
140 separator = scanner.scan(TOKEN_SPACE)
141 break if separator.nil?
142 end
143
144 return nil if scanner.scan(TOKEN_CLOSE_CURLY).nil? || unicode_string.empty?
145
146 unicode_string
147 end
148 private :unicode_long_hex_characters
149
150 def single_quoted_string(scanner)
151 quoted_string = ''
152
153 match = scanner.scan(TOKEN_SINGLE_QUOTE)
154 return nil if match.nil?
155
156 loop do
157 match = single_quote_char(scanner)
158 break if match.nil?
159
160 quoted_string << match
161 end
162
163 match = scanner.scan(TOKEN_SINGLE_QUOTE)
164 return quoted_string if match
165
166 nil
167 end
168 private :single_quoted_string
169
170 def double_quote_char(scanner)
171 double_quote_escaped_char(scanner) || double_quote_unescaped_char(scanner)
172 end
173 private :double_quote_char
174
175 def double_quoted_string(scanner)
176 quoted_string = ''
177
178 match = scanner.scan(TOKEN_DOUBLE_QUOTE)
179 return nil if match.nil?
180
181 loop do
182 match = double_quote_char(scanner)
183 break if match.nil?
184
185 quoted_string << match
186 end
187
188 match = scanner.scan(TOKEN_DOUBLE_QUOTE)
189 return quoted_string if match
190
191 nil
192 end
193 private :double_quoted_string
194
195 def quoted_string(scanner)
196 single_quoted_string(scanner) || double_quoted_string(scanner)
197 end
198 private :quoted_string
199
200 def array_values(scanner)
201 values = []
202
203 loop do
204 match = quoted_string(scanner)
205 break if match.nil?
206 values << match
207
208 match = array_separator(scanner)
209 break if match.nil?
210 end
211
212 values
213 end
214 private :array_values
215 end