Class: Parslet::Slice

Inherits:
Object
  • Object
show all
Defined in:
lib/parslet/slice.rb

Overview

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.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(position, string, line_cache = nil) ⇒ Slice

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.



33
34
35
36
37
# File 'lib/parslet/slice.rb', line 33

def initialize(position, string, line_cache=nil)
  @position = position
  @str = string
  @line_cache = line_cache
end

Instance Attribute Details

#line_cacheObject (readonly)

Returns the value of attribute line_cache



28
29
30
# File 'lib/parslet/slice.rb', line 28

def line_cache
  @line_cache
end

#positionObject (readonly)

Returns the value of attribute position



27
28
29
# File 'lib/parslet/slice.rb', line 27

def position
  @position
end

#strObject (readonly)

Returns the value of attribute str



26
27
28
# File 'lib/parslet/slice.rb', line 26

def str
  @str
end

Instance Method Details

#+(other) ⇒ Object

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.



67
68
69
# File 'lib/parslet/slice.rb', line 67

def +(other)
  self.class.new(@position, str + other.to_s, line_cache)
end

#==(other) ⇒ Object

Compares slices to other slices or strings.



45
46
47
# File 'lib/parslet/slice.rb', line 45

def == other
  str == other
end

#inspectObject

Prints the slice as "string"@offset.



106
107
108
109
# File 'lib/parslet/slice.rb', line 106

def inspect

  str.inspect << "@#{offset}"
end

#line_and_columnObject

Returns a <line, column> tuple referring to the original input.

Raises:

  • (ArgumentError)


73
74
75
76
77
78
# File 'lib/parslet/slice.rb', line 73

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

#match(regexp) ⇒ Object

Match regular expressions.



51
52
53
# File 'lib/parslet/slice.rb', line 51

def match(regexp)
  str.match(regexp)
end

#offsetObject



39
40
41
# File 'lib/parslet/slice.rb', line 39

def offset
  @position.charpos
end

#sizeObject Also known as: length

Returns the slices size in characters.



57
58
59
# File 'lib/parslet/slice.rb', line 57

def size
  str.size
end

#to_fObject



99
100
101
# File 'lib/parslet/slice.rb', line 99

def to_f
  str.to_f
end

#to_iObject



96
97
98
# File 'lib/parslet/slice.rb', line 96

def to_i
  str.to_i
end

#to_intObject



93
94
95
# File 'lib/parslet/slice.rb', line 93

def to_int
  Integer(str)
end

#to_sliceObject



87
88
89
# File 'lib/parslet/slice.rb', line 87

def to_slice
  self
end

#to_strObject Also known as: to_s

Conversion operators —————————————————–



82
83
84
# File 'lib/parslet/slice.rb', line 82

def to_str
  str
end

#to_symObject



90
91
92
# File 'lib/parslet/slice.rb', line 90

def to_sym
  str.to_sym
end