Class: Sequel::Postgres::PGRange::Parser

Inherits:
Object
  • Object
show all
Defined in:
lib/sequel/extensions/pg_range.rb

Overview

Creates callable objects that convert strings into PGRange instances.

Constant Summary collapse

PARSER =

Regexp that parses the full range of PostgreSQL range type output, except for empty ranges.

/\A(\[|\()("((?:\\"|[^"])*)"|[^"]*),("((?:\\"|[^"])*)"|[^"]*)(\]|\))\z/o
REPLACE_RE = 
/\\(.)/.freeze
REPLACE_WITH = 
'\1'.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(db_type, converter = nil) ⇒ Parser

Set the db_type and converter on initialization.



143
144
145
146
 
# File 'lib/sequel/extensions/pg_range.rb', line 143

def initialize(db_type, converter=nil)
  @db_type = db_type.to_s.dup.freeze if db_type
  @converter = converter
end

Instance Attribute Details

#converter ⇒ Object (readonly)

A callable object to convert the beginning and ending of the range into the appropriate ruby type.



140
141
142
 
# File 'lib/sequel/extensions/pg_range.rb', line 140

def converter
  @converter
end

#db_type ⇒ Object (readonly)

The database range type for this parser (e.g. ‘int4range’), automatically setting the db_type for the returned PGRange instances.



136
137
138
 
# File 'lib/sequel/extensions/pg_range.rb', line 136

def db_type
  @db_type
end

Instance Method Details

#call(string) ⇒ Object

Parse the range type input string into a PGRange value.

Raises:



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/sequel/extensions/pg_range.rb', line 149

def call(string)
  if string == EMPTY
    return PGRange.empty(db_type)
  end

  raise(InvalidValue, "invalid or unhandled range format: #{string.inspect}") unless matches = PARSER.match(string)

  exclude_begin = matches[1] == '('
  exclude_end = matches[6] == ')'

  # If the input is quoted, it needs to be unescaped.  Also, quoted input isn't
  # checked for emptiness, since the empty quoted string is considered an 
  # element that happens to be the empty string, while an unquoted empty string
  # is considered unbounded.
  #
  # While PostgreSQL allows pure escaping for input (without quoting), it appears
  # to always use the quoted output form when characters need to be escaped, so
  # there isn't a need to unescape unquoted output.
  if beg = matches[3]
    beg.gsub!(REPLACE_RE, REPLACE_WITH)
  else
    beg = matches[2] unless matches[2].empty?
  end
  if en = matches[5]
    en.gsub!(REPLACE_RE, REPLACE_WITH)
  else
    en = matches[4] unless matches[4].empty?
  end

  if c = converter
    beg = c.call(beg) if beg
    en = c.call(en) if en
  end

  PGRange.new(beg, en, :exclude_begin=>exclude_begin, :exclude_end=>exclude_end, :db_type=>db_type)
end