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_cache ⇒ Object (readonly)

Returns the value of attribute line_cache.



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

def line_cache
  @line_cache
end

#position ⇒ Object (readonly)

Returns the value of attribute position.



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

def position
  @position
end

#str ⇒ Object (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

#inspect ⇒ Object

Prints the slice as "string"@offset.



103
104
105
106
 
# File 'lib/parslet/slice.rb', line 103

def inspect

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

#line_and_column ⇒ Object

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

#offset ⇒ Object 



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

def offset
  @position.charpos
end

#size ⇒ Object 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_f ⇒ Object 



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

def to_f
  str.to_f
end

#to_i ⇒ Object 



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

def to_i
  self.str.to_i
end

#to_slice ⇒ Object 



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

def to_slice
  self
end

#to_str ⇒ Object Also known as: to_s

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



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

def to_str
  str
end

#to_sym ⇒ Object 



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

def to_sym
  str.to_sym
end