1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
# A slice is a small part from the parse input. A slice mainly behaves like
# any other string, except that it remembers where it came from (offset in
# original input).
#
# == Extracting line and column
#
# Using the #line_and_column method, you can extract the line and column in
# the original input where this slice starts.
#
# Example:
# slice.line_and_column # => [1, 13]
# slice.offset # => 12
#
# == Likeness to strings
#
# Parslet::Slice behaves in many ways like a Ruby String. This likeness
# however is not complete - many of the myriad of operations String supports
# are not yet in Slice. You can always extract the internal string instance by
# calling #to_s.
#
# These omissions are somewhat intentional. Rather than maintaining a full
# delegation, we opt for a partial emulation that gets the job done.
#
class Parslet::Slice
attr_reader :str
attr_reader :position
attr_reader :line_cache
# Construct a slice using a string, an offset and an optional line cache.
# The line cache should be able to answer to the #line_and_column message.
#
def initialize(position, string, line_cache=nil)
@position = position
@str = string
@line_cache = line_cache
end
def offset
@position.charpos
end
# Compares slices to other slices or strings.
#
def == other
str == other
end
# Match regular expressions.
#
def match(regexp)
str.match(regexp)
end
# Returns the slices size in characters.
#
def size
str.size
end
# Concatenate two slices; it is assumed that the second slice begins
# where the first one ends. The offset of the resulting slice is the same
# as the one of this slice.
#
def +(other)
self.class.new(@position, str + other.to_s, line_cache)
end
# Returns a <line, column> tuple referring to the original input.
#
def line_and_column
raise ArgumentError, "No line cache was given, cannot infer line and column." \
unless line_cache
line_cache.line_and_column(@position.bytepos)
end
# Conversion operators -----------------------------------------------------
def to_str
str
end
alias to_s to_str
def to_slice
self
end
def to_sym
str.to_sym
end
def to_int
Integer(str)
end
def to_i
str.to_i
end
def to_f
str.to_f
end
# Inspection & Debugging ---------------------------------------------------
# Prints the slice as <code>"string"@offset</code>.
def inspect
str.inspect << "@#{offset}"
end
end
|
