Class: RDF::URI

Inherits:
Object
  • Object
show all
Includes:
Resource
Defined in:
lib/rdf/model/uri.rb

Overview

A Uniform Resource Identifier (URI). Also compatible with International Resource Identifier (IRI)

Examples:

Creating a URI reference (1)

uri = RDF::URI.new("https://rubygems.org/gems/rdf")

Creating a URI reference (2)

uri = RDF::URI.new(scheme: 'http', host: 'rubygems.org', path: '/gems/rdf')
  #=> RDF::URI.new("https://rubygems.org/gems/rdf")

Creating an interned URI reference

uri = RDF::URI.intern("https://rubygems.org/gems/rdf")

Getting the string representation of a URI

uri.to_s #=> "https://rubygems.org/gems/rdf"

See Also:

Constant Summary collapse

UCSCHAR =

IRI components

%(
  \\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF
  \\u{10000}-\\u{1FFFD}\\u{20000}-\\u{2FFFD}\\u{30000}-\\u{3FFFD}
  \\u{40000}-\\u{4FFFD}\\u{50000}-\\u{5FFFD}\\u{60000}-\\u{6FFFD}
  \\u{70000}-\\u{7FFFD}\\u{80000}-\\u{8FFFD}\\u{90000}-\\u{9FFFD}
  \\u{A0000}-\\u{AFFFD}\\u{B0000}-\\u{BFFFD}\\u{C0000}-\\u{CFFFD}
  \\u{D0000}-\\u{DFFFD}\\u{E1000}-\\u{EFFFD}
).gsub(/\s+/, '')
IPRIVATE = 
Regexp.compile("[\\uE000-\\uF8FF\\u{F0000}-\\u{FFFFD}\\u{100000}-\\u{10FFFD}]").freeze
SCHEME = 
Regexp.compile("[A-Za-z](?:[A-Za-z0-9+-\.])*").freeze
PORT = 
Regexp.compile("[0-9]*").freeze
IP_literal =

Simplified, no IPvFuture

Regexp.compile("\\[[0-9A-Fa-f:\\.]*\\]").freeze
PCT_ENCODED = 
Regexp.compile("%[0-9A-Fa-f][0-9A-Fa-f]").freeze
GEN_DELIMS = 
Regexp.compile(%q{[:/\?\#\[\]@]}).freeze
SUB_DELIMS = 
Regexp.compile(%q{[!\$&'\(\)\*\+,;=]}).freeze
RESERVED = 
Regexp.union(GEN_DELIMS, SUB_DELIMS).freeze
UNRESERVED = 
Regexp.compile("[A-Za-z0-9\._~-]").freeze
IUNRESERVED = 
Regexp.union(UNRESERVED, Regexp.compile("[#{UCSCHAR}]")).freeze
IPCHAR = 
Regexp.union(IUNRESERVED, PCT_ENCODED, SUB_DELIMS, /[:|@]/).freeze
IQUERY = 
Regexp.compile("(?:#{IPCHAR}|#{IPRIVATE}|/|\\?)*").freeze
IFRAGMENT = 
Regexp.compile("(?:#{IPCHAR}|/|\\?)*").freeze
ISEGMENT = 
Regexp.compile("(?:#{IPCHAR})*").freeze
ISEGMENT_NZ = 
Regexp.compile("(?:#{IPCHAR})+").freeze
ISEGMENT_NZ_NC = 
Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS})|@)+").freeze
IPATH_ABEMPTY = 
Regexp.compile("(?:/#{ISEGMENT})*").freeze
IPATH_ABSOLUTE = 
Regexp.compile("/(?:(?:#{ISEGMENT_NZ})(/#{ISEGMENT})*)?").freeze
IPATH_NOSCHEME = 
Regexp.compile("(?:#{ISEGMENT_NZ_NC})(?:/#{ISEGMENT})*").freeze
IPATH_ROOTLESS = 
Regexp.compile("(?:#{ISEGMENT_NZ})(?:/#{ISEGMENT})*").freeze
IPATH_EMPTY = 
Regexp.compile("").freeze
IREG_NAME = 
Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS}))*").freeze
IHOST = 
Regexp.union(IP_literal, IREG_NAME).freeze
IUSERINFO = 
Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS})|:)*").freeze
IAUTHORITY = 
Regexp.compile("(?:#{IUSERINFO}@)?#{IHOST}(?::#{PORT})?").freeze
IRELATIVE_PART = 
Regexp.compile("//#{IAUTHORITY}(?:#{IPATH_ABEMPTY})|(?:#{IPATH_ABSOLUTE})|(?:#{IPATH_NOSCHEME})|(?:#{IPATH_EMPTY})").freeze
IRELATIVE_REF = 
Regexp.compile("^(?:#{IRELATIVE_PART})(?:\\?#{IQUERY})?(?:\\##{IFRAGMENT})?$").freeze
IHIER_PART = 
Regexp.compile("//#{IAUTHORITY}(?:#{IPATH_ABEMPTY})|(?:#{IPATH_ABSOLUTE})|(?:#{IPATH_ROOTLESS})|(?:#{IPATH_EMPTY})").freeze
IRI = 
Regexp.compile("^#{SCHEME}:(?:#{IHIER_PART})(?:\\?#{IQUERY})?(?:\\##{IFRAGMENT})?$").freeze
IRI_PARTS =

Split an IRI into it’s component parts scheme, authority, path, query, fragment

/^(?:([^:\/?#]+):)?(?:\/\/([^\/?#]*))?([^?#]*)(\?[^#]*)?(#.*)?$/.freeze
RDS_2A =

Remove dot expressions regular expressions

/^\.?\.\/(.*)$/.freeze
RDS_2B1 = 
/^\/\.$/.freeze
RDS_2B2 = 
/^(?:\/\.\/)(.*)$/.freeze
RDS_2C1 = 
/^\/\.\.$/.freeze
RDS_2C2 = 
/^(?:\/\.\.\/)(.*)$/.freeze
RDS_2D = 
/^\.\.?$/.freeze
RDS_2E = 
/^(\/?[^\/]*)(\/?.*)?$/.freeze
PORT_MAPPING =

Remove port, if it is standard for the scheme when normalizing

{
  "http"     => 80,
  "https"    => 443,
  "ftp"      => 21,
  "tftp"     => 69,
  "sftp"     => 22,
  "ssh"      => 22,
  "svn+ssh"  => 22,
  "telnet"   => 23,
  "nntp"     => 119,
  "gopher"   => 70,
  "wais"     => 210,
  "ldap"     => 389,
  "prospero" => 1525
}
NON_HIER_SCHEMES =

List of schemes known not to be hierarchical

%w(
  about acct bitcoin callto cid data fax geo gtalk h323 iax icon im jabber
  jms magnet mailto maps news pres proxy session sip sips skype sms spotify stun stuns
  tag tel turn turns tv urn javascript
).freeze
PN_ESCAPE_CHARS =

Characters in a PName which must be escaped Note: not all reserved characters need to be escaped in SPARQL/Turtle, but they must be unescaped when encountered

/[~\.!\$&'\(\)\*\+,;=\/\?\#@%]/.freeze
PN_ESCAPES = 
/\\#{Regexp.union(PN_ESCAPE_CHARS, /[\-_]/)}/.freeze
ENCODE_USER =

For URI encoding iuserinfo = *( iunreserved / pct-encoded / sub-delims / “:” )

ENCODE_PASSWORD = Regexp.compile("[^A-Za-z0-9\._~#{UCSCHAR}!$&'\(\)\*\+,;=:-]").freeze
ENCODE_ISEGMENT =

isegment = *ipchar ipchar = iunreserved / pct-encoded / sub-delims / “:” / “@”

Regexp.compile("[^A-Za-z0-9\._~#{UCSCHAR}!$&'\(\)\*\+,;=:-]").freeze
ENCODE_ISEGMENT_NC =

isegment-nz-nc = 1*( iunreserved / pct-encoded / sub-delims / “@” )

Regexp.compile("[^A-Za-z0-9\._~#{UCSCHAR}!$&'\(\)\*\+,;=-]").freeze
ENCODE_IQUERY =

iquery = *( ipchar / iprivate / “/” / “?” )

Regexp.compile("[^A-Za-z0-9\._~#{UCSCHAR}\\uE000-\\uF8FF\\u{F0000}-\\u{FFFFD}\\u{100000}-\\u{10FFFD}/?=]").freeze
ENCODE_IFRAGMENT =

ifragment = *( ipchar / “/” / “?” )

Regexp.compile("[^A-Za-z0-9\._~#{UCSCHAR}/?]").freeze
HOST_FROM_AUTHORITY_RE = 
/(?:[^@]+@)?([^:]+)(?::.*)?$/.freeze
PORT_FROM_AUTHORITY_RE = 
/:(\d+)$/.freeze

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Resource

new, #resource?

Methods included from Term

#<=>, #compatible?, #term?, #terms, #to_base, #to_term

Methods included from Value

#anonymous?, #constant?, #graph?, #inspect!, #invalid?, #iri?, #list?, #literal?, #node?, #resource?, #start_with?, #statement?, #term?, #to_nquads, #to_ntriples, #to_rdf, #to_term, #type_error, #variable?

Constructor Details

#initialize(uri, **options) ⇒ URI #initialize(**options) ⇒ URI

Returns a new instance of URI.

Overloads:

  • #initialize(uri, **options) ⇒ URI

    Parameters:

  • #initialize(**options) ⇒ URI

    Parameters:

    • options (Hash{Symbol => Object})
    • validate (Boolean) —

      (false)

    • canonicalize (Boolean) —

      (false)



241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/rdf/model/uri.rb', line 241

def initialize(*args, validate: false, canonicalize: false, **options)
  @value = @object = @hash = nil
  @mutex = Mutex.new
  uri = args.first
  if uri
    @value = uri.to_s.dup
    @value.dup.force_encoding(Encoding::UTF_8) if @value.encoding != Encoding::UTF_8
    @value.freeze
  else
    %i(
      scheme
      user password userinfo
      host port authority
      path query fragment
    ).each do |meth|
      if options.key?(meth)
        self.send("#{meth}=".to_sym, options[meth])
      else
        self.send(meth)
      end
    end
  end

  validate!     if validate
  canonicalize! if canonicalize
end

Class Method Details

._load(data) ⇒ RDF::URI

Load dumped data to reconsitute marshaled object This override is needed to avoid serializing @mutex.

Parameters:

  • data (String) —

    The dump of data needed to reconsitute this object.

Returns:

  • (RDF::URI) —

    The reconsituted object.



1342
1343
1344
 
# File 'lib/rdf/model/uri.rb', line 1342

def self._load(data)
  new(data)
end

.cache ⇒ RDF::Util::Cache

Cache size may be set through RDF.config using ‘uri_cache_size`.

Returns:



140
141
142
143
 
# File 'lib/rdf/model/uri.rb', line 140

def self.cache
  require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
  @cache ||= RDF::Util::Cache.new(RDF.config.uri_cache_size)
end

.intern(str, *args, **options) ⇒ RDF::URI

Returns an interned ‘RDF::URI` instance based on the given `uri` string.

The maximum number of cached interned URI references is given by the ‘CACHE_SIZE` constant. This value is unlimited by default, in which case an interned URI object will be purged only when the last strong reference to it is garbage collected (i.e., when its finalizer runs).

Excepting special memory-limited circumstances, it should always be safe and preferred to construct new URI references using ‘RDF::URI.intern` instead of `RDF::URI.new`, since if an interned object can’t be returned for some reason, this method will fall back to returning a freshly-allocated one.

(see #initialize)

Returns:

  • (RDF::URI) —

    an immutable, frozen URI object



162
163
164
 
# File 'lib/rdf/model/uri.rb', line 162

def self.intern(str, *args, **options)
  (cache[(str = str.to_s).to_sym] ||= self.new(str, *args, **options)).freeze
end

.normalize_path(path) ⇒ String

TODO:

This process is correct, but overly iterative. It could be better done with a single regexp which handled most of the segment collapses all at once. Parent segments would still require iteration.

Resolve paths to their simplest form.

Parameters:

  • path (String)

Returns:

  • (String) —

    normalized path

See Also:



187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/rdf/model/uri.rb', line 187

def self.normalize_path(path)
  output, input = String.new, path.to_s
  if input.encoding != Encoding::ASCII_8BIT
    input = input.dup.force_encoding(Encoding::ASCII_8BIT)
  end
  until input.empty?
    if input.match(RDS_2A)
      # If the input buffer begins with a prefix of "../" or "./", then remove that prefix from the input buffer; otherwise,
      input = $1
    elsif input.match(RDS_2B1) || input.match(RDS_2B2)
      # if the input buffer begins with a prefix of "/./" or "/.", where "." is a complete path segment, then replace that prefix with "/" in the input buffer; otherwise,
      input = "/#{$1}"
    elsif input.match(RDS_2C1) || input.match(RDS_2C2)
      # if the input buffer begins with a prefix of "/../" or "/..", where ".." is a complete path segment, then replace that prefix with "/" in the input buffer
      input = "/#{$1}"

      #  and remove the last segment and its preceding "/" (if any) from the output buffer; otherwise,
      output.sub!(/\/?[^\/]*$/, '')
    elsif input.match(RDS_2D)
      # if the input buffer consists only of "." or "..", then remove that from the input buffer; otherwise,
      input = ""
    elsif input.match(RDS_2E)
      # move the first path segment in the input buffer to the end of the output buffer, including the initial "/" character (if any) and any subsequent characters up to, but not including, the next "/" character or the end of the input buffer.end
      seg, input = $1, $2
      output << seg
    end
  end

  output.force_encoding(Encoding::UTF_8)
end

.parse(str) ⇒ RDF::URI

Creates a new ‘RDF::URI` instance based on the given `uri` string.

This is just an alias for #initialize for compatibity with ‘Addressable::URI.parse`. Actual parsing is defered until #object is accessed.

Parameters:

  • str (String, #to_s)

Returns:



175
176
177
 
# File 'lib/rdf/model/uri.rb', line 175

def self.parse(str)
  self.new(str)
end

Instance Method Details

#+(other) ⇒ RDF::URI

Simple concatenation operator. Returns a URI formed from concatenating the string form of two elements.

For building URIs from fragments, you may want to use the smart separator, ‘#/`. `#join` implements another set of URI building semantics.

Examples:

Concatenating a string to a URI

RDF::URI.new('http://example.org/test') + 'test'
#=> RDF::URI('http://example.org/testtest')

Concatenating two URIs

RDF::URI.new('http://example.org/test') + RDF::URI.new('test')
#=> RDF::URI('http://example.org/testtest')

Parameters:

  • other (Any)

Returns:

See Also:



570
571
572
 
# File 'lib/rdf/model/uri.rb', line 570

def +(other)
  RDF::URI.intern(self.to_s + other.to_s)
end

#/(fragment) ⇒ RDF::URI

‘Smart separator’ URI builder

This method attempts to use some understanding of the most common use cases for URLs and URNs to create a simple method for building new URIs from fragments. This means that it will always insert a separator of some sort, will remove duplicate seperators, will always assume that a fragment argument represents a relative and not absolute path, and throws an exception when an absolute URI is received for a fragment argument.

This is separate from the semantics for ‘#join`, which are well-defined by RFC3986 section 5.2 as part of the merging and normalization process; this method does not perform any normalization, removal of spurious paths, or removal of parent directory references `(/../)`.

When ‘fragment` is a path segment containing a colon, best practice is to prepend a `./` and use #join, which resolves dot-segments.

See also ‘#+`, which concatenates the string forms of two URIs without any sort of checking or processing.

For an up-to-date list of edge case behavior, see the shared examples for RDF::URI in the rdf-spec project.

Examples:

Building a HTTP URL

RDF::URI.new('http://example.org') / 'jhacker' / 'foaf.ttl'
#=> RDF::URI('http://example.org/jhacker/foaf.ttl')

Building a HTTP URL (absolute path components)

RDF::URI.new('http://example.org/') / '/jhacker/' / '/foaf.ttl'
#=> RDF::URI('http://example.org/jhacker/foaf.ttl')

Using an anchored base URI

RDF::URI.new('http://example.org/users#') / 'jhacker'
#=> RDF::URI('http://example.org/users#jhacker')

Building a URN

RDF::URI.new('urn:isbn') / 125235111
#=> RDF::URI('urn:isbn:125235111')

Parameters:

  • fragment (Any) —

    A URI fragment to be appended to this URI

Returns:

Raises:

  • (ArgumentError) —

    if the URI is invalid

See Also:



515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
 
# File 'lib/rdf/model/uri.rb', line 515

def /(fragment)
  frag = fragment.respond_to?(:to_uri) ? fragment.to_uri : RDF::URI(fragment.to_s)
  raise ArgumentError, "Non-absolute URI or string required, got #{frag}" unless frag.relative?
  if urn?
    RDF::URI.intern(to_s.sub(/:+$/,'') + ':' + fragment.to_s.sub(/^:+/,''))
  else # !urn?
    res = self.dup
    if res.fragment
      case fragment.to_s[0,1]
      when '/'
        # Base with a fragment, fragment beginning with '/'. The fragment wins, we use '/'.
        path, frag = fragment.to_s.split('#', 2)
        res.path = "#{res.path}/#{path.sub(/^\/*/,'')}"
        res.fragment = frag
      else
        # Replace fragment
        res.fragment = fragment.to_s.sub(/^#+/,'')
      end
    else
      # Not a fragment. includes '/'. Results from bases ending in '/' are the same as if there were no trailing slash.
      case fragment.to_s[0,1]
      when '#'
        # Base ending with '/', fragment beginning with '#'. The fragment wins, we use '#'.
        res.path = res.path.to_s.sub(/\/*$/, '')
        # Add fragment
        res.fragment = fragment.to_s.sub(/^#+/,'')
      else
        # Add fragment as path component
        path, frag = fragment.to_s.split('#', 2)
        res.path = res.path.to_s.sub(/\/*$/,'/') + path.sub(/^\/*/,'')
        res.fragment = frag
      end
    end
    RDF::URI.intern(res.to_s)
  end
end

#==(other) ⇒ Boolean

Checks whether this URI is equal to ‘other` (type checking).

Per SPARQL data-r2/expr-equal/eq-2-2, numeric can’t be compared with other types

Examples:

RDF::URI('http://t.co/') == RDF::URI('http://t.co/')    #=> true
RDF::URI('http://t.co/') == 'http://t.co/'              #=> true
RDF::URI('http://www.w3.org/2000/01/rdf-schema#') == RDF::RDFS        #=> true

Parameters:

  • other (Object)

Returns:

  • (Boolean) —

    ‘true` or `false`

See Also:



775
776
777
778
779
780
781
782
783
784
 
# File 'lib/rdf/model/uri.rb', line 775

def ==(other)
  case other
  when Literal
    # If other is a Literal, reverse test to consolodate complex type checking logic
    other == self
  when String then to_s == other
  when URI then hash == other.hash && to_s == other.to_s
  else other.respond_to?(:to_uri) && to_s == other.to_uri.to_s
  end
end

#===(other) ⇒ Boolean

Checks for case equality to the given ‘other` object.

Examples:

RDF::URI('http://example.org/') === /example/           #=> true
RDF::URI('http://example.org/') === /foobar/            #=> false
RDF::URI('http://t.co/') === RDF::URI('http://t.co/')   #=> true
RDF::URI('http://t.co/') === 'http://t.co/'             #=> true
RDF::URI('http://www.w3.org/2000/01/rdf-schema#') === RDF::RDFS       #=> true

Parameters:

  • other (Object)

Returns:

  • (Boolean) —

    ‘true` or `false`

Since:

  • 0.3.0



799
800
801
802
803
804
 
# File 'lib/rdf/model/uri.rb', line 799

def ===(other)
  case other
    when Regexp then other === to_s
    else self == other
  end
end

#=~(pattern) ⇒ Integer

Performs a pattern match using the given regular expression.

Examples:

RDF::URI('http://example.org/') =~ /example/            #=> 7
RDF::URI('http://example.org/') =~ /foobar/             #=> nil

Parameters:

  • pattern (Regexp)

Returns:

  • (Integer) —

    the position the match starts

See Also:

  • String#=~

Since:

  • 0.3.0



817
818
819
820
821
822
 
# File 'lib/rdf/model/uri.rb', line 817

def =~(pattern)
  case pattern
    when Regexp then to_s =~ pattern
    else super # `Object#=~` returns `false`
  end
end

#_dump(level) ⇒ String

Dump of data needed to reconsitute this object using Marshal.load This override is needed to avoid serializing @mutex.

Parameters:

  • level (Integer) —

    The maximum depth of objects to dump.

Returns:

  • (String) —

    The dump of data needed to reconsitute this object.



1332
1333
1334
 
# File 'lib/rdf/model/uri.rb', line 1332

def _dump(level)
  value
end

#absolute? ⇒ Boolean

A URI is absolute when it has a scheme

Returns:

  • (Boolean) —

    ‘true` or `false`



321
 
# File 'lib/rdf/model/uri.rb', line 321

def absolute?; !scheme.nil?; end

#authority ⇒ Object

Authority is a combination of user, password, host and port



1169
1170
1171
1172
1173
 
# File 'lib/rdf/model/uri.rb', line 1169

def authority
  object.fetch(:authority) {
    @object[:authority] = (format_authority if @object[:host])
  }
end

#authority=(value) ⇒ RDF::URI

Returns self.

Parameters:

  • value (String, #to_s)

Returns:



1178
1179
1180
1181
1182
1183
1184
 
# File 'lib/rdf/model/uri.rb', line 1178

def authority=(value)
  object.delete_if {|k, v| %i(user password host port userinfo).include?(k)}
  object[:authority] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
  user; password; userinfo; host; port
  @value = nil
  self
end

#canonicalize ⇒ RDF::URI Also known as: normalize

Returns a copy of this URI converted into its canonical lexical representation.

Returns:

Since:

  • 0.3.0



391
392
393
 
# File 'lib/rdf/model/uri.rb', line 391

def canonicalize
  self.dup.canonicalize!
end

#canonicalize! ⇒ RDF::URI Also known as: normalize!

Converts this URI into its canonical lexical representation.

Returns:

Since:

  • 0.3.0



401
402
403
404
405
406
407
408
409
410
411
412
 
# File 'lib/rdf/model/uri.rb', line 401

def canonicalize!
  @object = {
    scheme: normalized_scheme,
    authority: normalized_authority,
    path: normalized_path.squeeze('/'),
    query: normalized_query,
    fragment: normalized_fragment
  }
  @value = nil
  @hash = nil
  self
end

#dup ⇒ RDF::URI

Returns a duplicate copy of ‘self`.

Returns:



712
713
714
 
# File 'lib/rdf/model/uri.rb', line 712

def dup
  self.class.new(@value, **(@object || {}))
end

#end_with?(string) ⇒ Boolean Also known as: ends_with?

Returns ‘true` if this URI ends with the given `string`.

Examples:

RDF::URI('http://example.org/').end_with?('/')          #=> true
RDF::URI('http://example.org/').end_with?('#')          #=> false

Parameters:

  • string (String, #to_s)

Returns:

  • (Boolean) —

    ‘true` or `false`

See Also:

  • String#end_with?

Since:

  • 0.3.0



743
744
745
 
# File 'lib/rdf/model/uri.rb', line 743

def end_with?(string)
  to_s.end_with?(string.to_s)
end

#eql?(other) ⇒ Boolean

Checks whether this URI the same term as ‘other`.

Examples:

RDF::URI('http://t.co/').eql?(RDF::URI('http://t.co/'))    #=> true
RDF::URI('http://t.co/').eql?('http://t.co/')              #=> false
RDF::URI('http://www.w3.org/2000/01/rdf-schema#').eql?(RDF::RDFS) #=> false

Parameters:

Returns:

  • (Boolean) —

    ‘true` or `false`



758
759
760
 
# File 'lib/rdf/model/uri.rb', line 758

def eql?(other)
  other.is_a?(URI) && self.hash == other.hash && self == other
end

#fragment ⇒ String

Returns:

  • (String) 


1145
1146
1147
1148
1149
 
# File 'lib/rdf/model/uri.rb', line 1145

def fragment
  object.fetch(:fragment) do
    nil
  end
end

#fragment=(value) ⇒ RDF::URI

Returns self.

Parameters:

  • value (String, #to_s)

Returns:



1154
1155
1156
1157
1158
 
# File 'lib/rdf/model/uri.rb', line 1154

def fragment=(value)
  object[:fragment] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
  @value = nil
  self
end

#freeze ⇒ Object 



718
719
720
721
722
723
724
725
726
727
728
729
730
 
# File 'lib/rdf/model/uri.rb', line 718

def freeze
  unless frozen?
    @mutex.synchronize do
      # Create derived components
      authority; userinfo; user; password; host; port
      @value  = value.freeze
      @object = object.freeze
      @hash = hash.freeze
      super
    end
  end
  self
end

#hash ⇒ Integer

Returns a hash code for this URI.

Returns:

  • (Integer) 


868
869
870
 
# File 'lib/rdf/model/uri.rb', line 868

def hash
  @hash || @hash = (value.hash * -1)
end

#hier? ⇒ Boolean

Returns ‘true` if the URI scheme is hierarchical.

Examples:

RDF::URI('http://example.org/').hier?                    #=> true
RDF::URI('urn:isbn:125235111').hier?                     #=> false

Returns:

  • (Boolean) —

    ‘true` or `false`

See Also:

Since:

  • 1.0.10



301
302
303
 
# File 'lib/rdf/model/uri.rb', line 301

def hier?
  !NON_HIER_SCHEMES.include?(scheme)
end

#host ⇒ String

Returns:

  • (String) 


997
998
999
1000
1001
 
# File 'lib/rdf/model/uri.rb', line 997

def host
  object.fetch(:host) do
    @object[:host] = ($1 if @object[:authority] && HOST_FROM_AUTHORITY_RE.match(@object[:authority]))
  end
end

#host=(value) ⇒ RDF::URI

Returns self.

Parameters:

  • value (String, #to_s)

Returns:



1006
1007
1008
1009
1010
1011
 
# File 'lib/rdf/model/uri.rb', line 1006

def host=(value)
  object[:host] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
  @object[:authority] = format_authority
  @value = nil
  self
end

#inspect ⇒ String

Returns a String representation of the URI object’s state.

Returns:

  • (String) —

    The URI object’s state, as a String.



846
847
848
 
# File 'lib/rdf/model/uri.rb', line 846

def inspect
  sprintf("#<%s:%#0x URI:%s>", URI.to_s, self.object_id, self.to_s)
end

#join(*uris) ⇒ RDF::URI

Joins several URIs together.

This method conforms to join normalization semantics as per RFC3986, section 5.2. This method normalizes URIs, removes some duplicate path information, such as double slashes, and other behavior specified in the RFC.

Other URI building methods are ‘#/` and `#+`.

For an up-to-date list of edge case behavior, see the shared examples for RDF::URI in the rdf-spec project.

Examples:

Joining two URIs

RDF::URI.new('http://example.org/foo/bar').join('/foo')
#=> RDF::URI('http://example.org/foo')

Parameters:

  • uris (Array<String, RDF::URI, #to_s>) —

    absolute or relative URIs.

Returns:

See Also:



439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
 
# File 'lib/rdf/model/uri.rb', line 439

def join(*uris)
  joined_parts = object.dup.delete_if {|k, v| %i(user password host port).include?(k)}

  uris.each do |uri|
    uri = RDF::URI.new(uri) unless uri.is_a?(RDF::URI)
    next if uri.to_s.empty? # Don't mess with base URI

    case
    when uri.scheme
      joined_parts = uri.object.merge(path: self.class.normalize_path(uri.path))
    when uri.authority
      joined_parts[:authority] = uri.authority
      joined_parts[:path] = self.class.normalize_path(uri.path)
      joined_parts[:query] = uri.query
    when uri.path.to_s.empty?
      joined_parts[:query] = uri.query if uri.query
    when uri.path[0,1] == '/'
      joined_parts[:path] = self.class.normalize_path(uri.path)
      joined_parts[:query] = uri.query
    else
      # Merge path segments from section 5.2.3
      # Note that if the path includes no segments, the entire path is removed
      #  > return a string consisting of the reference's path component appended to all but the last segment of the base URI's path (i.e., excluding any characters after the right-most "/" in the base URI path, or excluding the entire base URI path if it does not contain any "/" characters).
      base_path = path.to_s.include?('/') ? path.to_s.sub(/\/[^\/]*$/, '/') : ''
      joined_parts[:path] = self.class.normalize_path(base_path + uri.path)
      joined_parts[:query] = uri.query
    end
    joined_parts[:fragment] = uri.fragment
  end

  # Return joined URI
  RDF::URI.new(**joined_parts)
end

#length ⇒ Integer Also known as: size

Returns the string length of this URI.

Examples:

RDF::URI('http://example.org/').length                  #=> 19

Returns:

  • (Integer)

Since:

  • 0.3.0



358
359
360
 
# File 'lib/rdf/model/uri.rb', line 358

def length
  to_s.length
end

#normalized_authority ⇒ String

Return normalized version of authority, if any

Returns:

  • (String) 


1189
1190
1191
1192
1193
1194
1195
 
# File 'lib/rdf/model/uri.rb', line 1189

def normalized_authority
  if authority
    (userinfo ? normalized_userinfo.to_s + "@" : "") +
    normalized_host.to_s +
    (normalized_port ? ":" + normalized_port.to_s : "")
  end
end

#normalized_fragment ⇒ String

Normalized version of fragment

Returns:

  • (String) 


1163
1164
1165
 
# File 'lib/rdf/model/uri.rb', line 1163

def normalized_fragment
  normalize_segment(fragment, ENCODE_IFRAGMENT) if fragment
end

#normalized_host ⇒ String

Normalized version of host

Returns:

  • (String) 


1016
1017
1018
1019
 
# File 'lib/rdf/model/uri.rb', line 1016

def normalized_host
  # Remove trailing '.' characters
  host.sub(/\.*$/, '').downcase if host
end

#normalized_password ⇒ String

Normalized version of password

Returns:

  • (String) 


989
990
991
 
# File 'lib/rdf/model/uri.rb', line 989

def normalized_password
  URI.encode(CGI.unescape(password), ENCODE_PASSWORD).force_encoding(Encoding::UTF_8) if password
end

#normalized_path ⇒ String

Normalized version of path

Returns:

  • (String) 


1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
 
# File 'lib/rdf/model/uri.rb', line 1077

def normalized_path
  if normalized_scheme == "urn"
    # Special-case URI. Normalize the NID component only
    nid, p = path.to_s.split(':', 2)
    return "#{nid.downcase}:#{p}"
  end

  segments = path.to_s.split('/', -1) # preserve null segments

  norm_segs = case
  when authority
    # ipath-abempty
    segments.map {|s| normalize_segment(s, ENCODE_ISEGMENT)}
  when segments[0].nil?
    # ipath-absolute
    res = [nil]
    res << normalize_segment(segments[1], ENCODE_ISEGMENT) if segments.length > 1
    res += segments[2..-1].map {|s| normalize_segment(s, ENCODE_ISEGMENT)} if segments.length > 2
    res
  when segments[0].to_s.index(':')
    # ipath-noscheme
    res = []
    res << normalize_segment(segments[0], ENCODE_ISEGMENT_NC)
    res += segments[1..-1].map {|s| normalize_segment(s, ENCODE_ISEGMENT)} if segments.length > 1
    res
  when segments[0]
    # ipath-rootless
    # ipath-noscheme
    res = []
    res << normalize_segment(segments[0], ENCODE_ISEGMENT)
    res += segments[1..-1].map {|s| normalize_segment(s, ENCODE_ISEGMENT)} if segments.length > 1
    res
  else
    # Should be empty
    segments
  end

  res = self.class.normalize_path(norm_segs.join("/"))
  # Special rules for specific protocols having empty paths
  (res.empty? && %w(http https ftp tftp).include?(normalized_scheme)) ? '/' : res
end

#normalized_port ⇒ String

Normalized version of port

Returns:

  • (String) 


1044
1045
1046
1047
1048
1049
 
# File 'lib/rdf/model/uri.rb', line 1044

def normalized_port
  if port
    np = port.to_i
    PORT_MAPPING[normalized_scheme] != np ? np : nil
  end
end

#normalized_query ⇒ String

Normalized version of query

Returns:

  • (String) 


1139
1140
1141
 
# File 'lib/rdf/model/uri.rb', line 1139

def normalized_query
  normalize_segment(query, ENCODE_IQUERY) if query
end

#normalized_scheme ⇒ String

Return normalized version of scheme, if any

Returns:

  • (String) 


937
938
939
 
# File 'lib/rdf/model/uri.rb', line 937

def normalized_scheme
  scheme.strip.downcase if scheme
end

#normalized_user ⇒ String

Normalized version of user

Returns:

  • (String) 


963
964
965
 
# File 'lib/rdf/model/uri.rb', line 963

def normalized_user
  URI.encode(CGI.unescape(user), ENCODE_USER).force_encoding(Encoding::UTF_8) if user
end

#normalized_userinfo ⇒ String

Normalized version of userinfo

Returns:

  • (String) 


1219
1220
1221
 
# File 'lib/rdf/model/uri.rb', line 1219

def normalized_userinfo
  normalized_user + (password ? ":#{normalized_password}" : "") if userinfo
end

#object ⇒ Hash{Symbol => String} Also known as: to_h

Returns object representation of this URI, broken into components

Returns:

  • (Hash{Symbol => String}) 


876
877
878
 
# File 'lib/rdf/model/uri.rb', line 876

def object
  @object || @object = parse(@value)
end

#parent ⇒ RDF::URI

Returns a copy of this URI with the path component ascended to the parent directory, if any.

Examples:

RDF::URI('http://example.org/').parent                  #=> nil
RDF::URI('http://example.org/path/').parent             #=> RDF::URI('http://example.org/')

Returns:



630
631
632
633
634
635
636
637
638
639
640
641
642
 
# File 'lib/rdf/model/uri.rb', line 630

def parent
  case
    when root? then nil
    else
      require 'pathname' unless defined?(Pathname)
      if path = Pathname.new(self.path).parent
        uri = self.dup
        uri.path = path.to_s
        uri.path << '/' unless uri.root?
        uri
      end
  end
end

#parent? ⇒ Boolean Also known as: has_parent?

Returns ‘true` if this URI is hierarchical and it’s path component isn’t equal to ‘/`.

Examples:

RDF::URI('http://example.org/').parent?             #=> false
RDF::URI('http://example.org/path/').parent?        #=> true

Returns:

  • (Boolean) —

    ‘true` or `false`



616
617
618
 
# File 'lib/rdf/model/uri.rb', line 616

def parent?
  !root?
end

#parse(value) ⇒ Object{Symbol => String}

{ Parse a URI into it’s components

Parameters:

  • value (String, to_s)

Returns:

  • (Object{Symbol => String}) 


886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
 
# File 'lib/rdf/model/uri.rb', line 886

def parse(value)
  value = value.to_s.dup.force_encoding(Encoding::ASCII_8BIT)
  parts = {}
  if matchdata = IRI_PARTS.match(value)
    scheme, authority, path, query, fragment = matchdata[1..-1]

    if Gem.win_platform? && scheme && !authority && scheme.match?(/^[a-zA-Z]$/)
      # A drive letter, not a scheme
      scheme, path = nil, "#{scheme}:#{path}"
    end

    userinfo, hostport = authority.to_s.split('@', 2)
    hostport, userinfo = userinfo, nil unless hostport
    user, password = userinfo.to_s.split(':', 2)
    host, port = hostport.to_s.split(':', 2)

    parts[:scheme] = (scheme.dup.force_encoding(Encoding::UTF_8) if scheme)
    parts[:authority] = (authority.dup.force_encoding(Encoding::UTF_8) if authority)
    parts[:userinfo] = (userinfo.dup.force_encoding(Encoding::UTF_8) if userinfo)
    parts[:user] = (user.dup.force_encoding(Encoding::UTF_8) if user)
    parts[:password] = (password.dup.force_encoding(Encoding::UTF_8) if password)
    parts[:host] = (host.dup.force_encoding(Encoding::UTF_8) if host)
    parts[:port] = (CGI.unescape(port).to_i if port)
    parts[:path] = (path.to_s.dup.force_encoding(Encoding::UTF_8) unless path.empty?)
    parts[:query] = (query[1..-1].dup.force_encoding(Encoding::UTF_8) if query)
    parts[:fragment] = (fragment[1..-1].dup.force_encoding(Encoding::UTF_8) if fragment)
  end
  
  parts
end

#password ⇒ String

Returns:

  • (String) 


969
970
971
972
973
 
# File 'lib/rdf/model/uri.rb', line 969

def password
  object.fetch(:password) do
    @object[:password] = (userinfo.split(':', 2)[1] if userinfo)
  end
end

#password=(value) ⇒ RDF::URI

Returns self.

Parameters:

  • value (String, #to_s)

Returns:



978
979
980
981
982
983
984
 
# File 'lib/rdf/model/uri.rb', line 978

def password=(value)
  object[:password] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
  @object[:userinfo] = format_userinfo("")
  @object[:authority] = format_authority
  @value = nil
  self
end

#path ⇒ String

Returns:

  • (String) 


1053
1054
1055
1056
1057
 
# File 'lib/rdf/model/uri.rb', line 1053

def path
  object.fetch(:path) do
    nil
  end
end

#path=(value) ⇒ RDF::URI

Returns self.

Parameters:

  • value (String, #to_s)

Returns:



1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
 
# File 'lib/rdf/model/uri.rb', line 1062

def path=(value)
  if value
    # Always lead with a slash
    value = "/#{value}" if host && value.to_s.match?(/^[^\/]/)
    object[:path] = value.to_s.dup.force_encoding(Encoding::UTF_8)
  else
    object[:path] = nil
  end
  @value = nil
  self
end

#pname(prefixes: nil) ⇒ String

Returns a Prefixed Name (PName) or the full IRI with any [reserved characters](www.w3.org/TR/turtle/#reserved) in the suffix escaped.

Examples:

Using a custom prefix for creating a PNname.

RDF::URI('http://purl.org/dc/terms/creator').
  pname(prefixes: {dcterms: 'http://purl.org/dc/terms/'})
  #=> "dcterms:creator"

Parameters:

  • prefixes (Hash{Symbol => String}) (defaults to: nil) —

    Explicit set of prefixes to look for matches, defaults to loaded vocabularies.

Returns:

  • (String) —

    or ‘nil`

See Also:



699
700
701
702
703
704
705
706
 
# File 'lib/rdf/model/uri.rb', line 699

def pname(prefixes: nil)
  q = self.qname(prefixes: prefixes)
  return self.to_s unless q
  prefix, suffix = q
  suffix = suffix.to_s.gsub(PN_ESCAPE_CHARS) {|c| "\\#{c}"} if
    suffix.to_s.match?(PN_ESCAPE_CHARS)
  [prefix, suffix].join(":")
end

#port ⇒ String

Returns:

  • (String) 


1025
1026
1027
1028
1029
 
# File 'lib/rdf/model/uri.rb', line 1025

def port
  object.fetch(:port) do
    @object[:port] = ($1 if @object[:authority] && PORT_FROM_AUTHORITY_RE.match(@object[:authority]))
  end
end

#port=(value) ⇒ RDF::URI

Returns self.

Parameters:

  • value (String, #to_s)

Returns:



1034
1035
1036
1037
1038
1039
 
# File 'lib/rdf/model/uri.rb', line 1034

def port=(value)
  object[:port] = (value.to_s.to_i if value)
  @object[:authority] = format_authority
  @value = nil
  self
end

#qname(prefixes: nil) ⇒ Array(Symbol, Symbol)

Note:

within this software, the term QName is used to describe the tuple of prefix and suffix for a given IRI, where the prefix identifies some defined vocabulary. This somewhat contrasts with the notion of a [Qualified Name](www.w3.org/TR/2006/REC-xml-names11-20060816/#ns-qualnames) from XML, which are a subset of Prefixed Names.

Returns a qualified name (QName) as a tuple of ‘[prefix, suffix]` for this URI based on available vocabularies, if possible.

Examples:

RDF::URI('http://www.w3.org/2000/01/rdf-schema#').qname       #=> [:rdfs, nil]
RDF::URI('http://www.w3.org/2000/01/rdf-schema#label').qname  #=> [:rdfs, :label]
RDF::RDFS.label.qname                                         #=> [:rdfs, :label]
RDF::Vocab::DC.title.qname(
  prefixes: {dcterms: 'http://purl.org/dc/terms/'})           #=> [:dcterms, :title]

Parameters:

  • prefixes (Hash{Symbol => String}) (defaults to: nil) —

    Explicit set of prefixes to look for matches, defaults to loaded vocabularies.

Returns:

  • (Array(Symbol, Symbol)) —

    or ‘nil` if no QName found. The suffix component will not have [reserved characters](www.w3.org/TR/turtle/#reserved) escaped.



659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
 
# File 'lib/rdf/model/uri.rb', line 659

def qname(prefixes: nil)
  if prefixes
    prefixes.each do |prefix, uri|
      return [prefix, self.to_s[uri.length..-1].to_sym] if self.start_with?(uri)
    end
  elsif self.to_s =~ %r([:/#]([^:/#]*)$)
    local_name = $1
    vocab_uri  = local_name.empty? ? self.to_s : self.to_s[0...-(local_name.length)]
    Vocabulary.each do |vocab|
      if vocab.to_uri == vocab_uri
        prefix = vocab.equal?(RDF) ? :rdf : vocab.__prefix__
        return [prefix, local_name.empty? ? nil : local_name.to_sym]
      end
    end
  else
    Vocabulary.each do |vocab|
      vocab_uri = vocab.to_uri
      if self.start_with?(vocab_uri)
        prefix = vocab.equal?(RDF) ? :rdf : vocab.__prefix__
        local_name = self.to_s[vocab_uri.length..-1]
        return [prefix, local_name.empty? ? nil : local_name.to_sym]
      end
    end
  end
  return nil # no QName found
end

#query ⇒ String

Returns:

  • (String) 


1121
1122
1123
1124
1125
 
# File 'lib/rdf/model/uri.rb', line 1121

def query
  object.fetch(:query) do
    nil
  end
end

#query=(value) ⇒ RDF::URI

Returns self.

Parameters:

  • value (String, #to_s)

Returns:



1130
1131
1132
1133
1134
 
# File 'lib/rdf/model/uri.rb', line 1130

def query=(value)
  object[:query] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
  @value = nil
  self
end

#query_values(return_type = Hash) ⇒ Hash, Array

Converts the query component to a Hash value.

Examples:

RDF::URI.new("?one=1&two=2&three=3").query_values
#=> {"one" => "1", "two" => "2", "three" => "3"}
RDF::URI.new("?one=two&one=three").query_values(Array)
#=> [["one", "two"], ["one", "three"]]
RDF::URI.new("?one=two&one=three").query_values(Hash)
#=> {"one" => ["two", "three"]}

Parameters:

  • return_type (Class) (defaults to: Hash) —

    (Hash) The return type desired. Value must be either # ‘Hash` or `Array`.

Returns:

  • (Hash, Array) —

    The query string parsed as a Hash or Array object.

Raises:

  • (ArgumentError) 


1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
 
# File 'lib/rdf/model/uri.rb', line 1237

def query_values(return_type=Hash)
  raise ArgumentError, "Invalid return type. Must be Hash or Array." unless [Hash, Array].include?(return_type)
  return nil if query.nil?
  query.to_s.split('&').
    inject(return_type == Hash ? {} : []) do |memo,kv|
      k,v = kv.to_s.split('=', 2)
      unless k.to_s.empty?
        k = CGI.unescape(k)
        v = CGI.unescape(v) if v
        if return_type == Hash
          case memo[k]
          when nil then memo[k] = v
          when Array then memo[k] << v
          else memo[k] = [memo[k], v]
          end
        else
          memo << [k, v].compact
        end
      end
      memo
    end
end

#query_values=(value) ⇒ Object

Sets the query component for this URI from a Hash object. An empty Hash or Array will result in an empty query string.

Examples:

Hash with single and array values

uri.query_values = {a: "a", b: ["c", "d", "e"]}
uri.query
# => "a=a&b=c&b=d&b=e"

Array with Array values including repeated variables

uri.query_values = [['a', 'a'], ['b', 'c'], ['b', 'd'], ['b', 'e']]
uri.query
# => "a=a&b=c&b=d&b=e"

Array with Array values including multiple elements

uri.query_values = [['a', 'a'], ['b', ['c', 'd', 'e']]]
uri.query
# => "a=a&b=c&b=d&b=e"

Array with Array values having only one entry

uri.query_values = [['flag'], ['key', 'value']]
uri.query
# => "flag&key=value"

Parameters:

  • value (Hash, #to_hash, Array) —

    The new query values.



1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
 
# File 'lib/rdf/model/uri.rb', line 1285

def query_values=(value)
  if value.nil?
    self.query = nil
    return
  end

  value = value.to_hash if value.respond_to?(:to_hash)
  self.query = case value
  when Array, Hash
    value.map do |(k,v)|
      k = normalize_segment(k.to_s, /[^A-Za-z0-9\._~-]/)
      if v.nil?
        k
      else
        Array(v).map do |vv|
          if vv === TrueClass
            k
          else
            "#{k}=#{normalize_segment(vv.to_s, /[^A-Za-z0-9\._~-]/)}"
          end
        end.join("&")
      end
    end
  else
    raise TypeError,
      "Can't convert #{value.class} into Hash."
  end.join("&")
end

#relative? ⇒ Boolean

A URI is relative when it does not have a scheme

Returns:

  • (Boolean) —

    ‘true` or `false`



326
 
# File 'lib/rdf/model/uri.rb', line 326

def relative?; !absolute?; end

#relativize(base_uri) ⇒ RDF::URI

Attempt to make this URI relative to the provided ‘base_uri`. If successful, returns a relative URI, otherwise the original URI

Parameters:

Returns:



331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
 
# File 'lib/rdf/model/uri.rb', line 331

def relativize(base_uri)
  if self.to_s.start_with?(base_uri.to_s) && %w(# ?).include?(self.to_s[base_uri.to_s.length, 1]) ||
     base_uri.to_s.end_with?("/", "#") &&
     self.to_s.start_with?(base_uri.to_s)
    return RDF::URI(self.to_s[base_uri.to_s.length..-1])
  else
    # Create a list of parents, for which this IRI may be relative.
    u = RDF::URI(base_uri)
    iri_set = u.to_s.end_with?('/') ? [u.to_s] : []
    iri_set << u.to_s while (u = u.parent)
    iri_set.each_with_index do |bb, index|
      next unless self.to_s.start_with?(bb)
      rel = "../" * index + self.to_s[bb.length..-1]
      return rel.empty? ? "./" : rel
    end
  end
  self
end

#request_uri ⇒ String

The HTTP request URI for this URI. This is the path and the query string.

Returns:

  • (String) —

    The request URI required for an HTTP request.



1319
1320
1321
1322
1323
1324
 
# File 'lib/rdf/model/uri.rb', line 1319

def request_uri
  return nil if absolute? && scheme !~ /^https?$/
  res = path.to_s.empty? ? "/" : path
  res += "?#{self.query}" if self.query
  return res
end

#root ⇒ RDF::URI

Returns a copy of this URI with the path component set to ‘/`.

Examples:

RDF::URI('http://example.org/').root                    #=> RDF::URI('http://example.org/')
RDF::URI('http://example.org/path/').root               #=> RDF::URI('http://example.org/')

Returns:



598
599
600
601
602
603
604
605
606
 
# File 'lib/rdf/model/uri.rb', line 598

def root
  if root?
    self
  else
    RDF::URI.new(
      **object.merge(path: '/').
      keep_if {|k, v| %i(scheme authority path).include?(k)})
  end
end

#root? ⇒ Boolean

Returns ‘true` if this URI’s scheme is not hierarchical, or its path component is equal to ‘/`. Protocols not using hierarchical components are always considered to be at the root.

Examples:

RDF::URI('http://example.org/').root?                   #=> true
RDF::URI('http://example.org/path/').root?              #=> false
RDF::URI('urn:isbn').root?                              #=> true

Returns:

  • (Boolean) —

    ‘true` or `false`



586
587
588
 
# File 'lib/rdf/model/uri.rb', line 586

def root?
  !self.hier?  || self.path == '/' || self.path.to_s.empty?
end

#scheme ⇒ String

Returns:

  • (String) 


919
920
921
922
923
 
# File 'lib/rdf/model/uri.rb', line 919

def scheme
  object.fetch(:scheme) do
    nil
  end
end

#scheme=(value) ⇒ RDF::URI

Returns self.

Parameters:

  • value (String, #to_s)

Returns:



928
929
930
931
932
 
# File 'lib/rdf/model/uri.rb', line 928

def scheme=(value)
  object[:scheme] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
  @value = nil
  self
end

#to_str ⇒ String Also known as: to_s

Returns the string representation of this URI.

Examples:

RDF::URI('http://example.org/').to_str                  #=> 'http://example.org/'

Returns:

  • (String) 


839
 
# File 'lib/rdf/model/uri.rb', line 839

def to_str; value; end

#to_uri ⇒ RDF::URI

Returns ‘self`.

Returns:



828
829
830
 
# File 'lib/rdf/model/uri.rb', line 828

def to_uri
  self
end

#uri? ⇒ Boolean

Returns ‘true`.

Returns:

  • (Boolean) —

    ‘true` or `false`

See Also:



273
274
275
 
# File 'lib/rdf/model/uri.rb', line 273

def uri?
  true
end

#url? ⇒ Boolean

Returns ‘true` if this URI is a URL.

Examples:

RDF::URI('http://example.org/').url?                    #=> true

Returns:

  • (Boolean) —

    ‘true` or `false`

See Also:

Since:

  • 0.2.0



314
315
316
 
# File 'lib/rdf/model/uri.rb', line 314

def url?
  !urn?
end

#urn? ⇒ Boolean

Returns ‘true` if this URI is a URN.

Examples:

RDF::URI('http://example.org/').urn?                    #=> false

Returns:

  • (Boolean) —

    ‘true` or `false`

See Also:

Since:

  • 0.2.0



286
287
288
 
# File 'lib/rdf/model/uri.rb', line 286

def urn?
  @object ? @object[:scheme] == 'urn' : start_with?('urn:')
end

#user ⇒ String

Returns:

  • (String) 


943
944
945
946
947
 
# File 'lib/rdf/model/uri.rb', line 943

def user
  object.fetch(:user) do
    @object[:user] = (userinfo.split(':', 2)[0] if userinfo)
  end
end

#user=(value) ⇒ RDF::URI

Returns self.

Parameters:

  • value (String, #to_s)

Returns:



952
953
954
955
956
957
958
 
# File 'lib/rdf/model/uri.rb', line 952

def user=(value)
  object[:user] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
  @object[:userinfo] = format_userinfo("")
  @object[:authority] = format_authority
  @value = nil
  self
end

#userinfo ⇒ Object

Userinfo is a combination of user and password



1199
1200
1201
1202
1203
 
# File 'lib/rdf/model/uri.rb', line 1199

def userinfo
  object.fetch(:userinfo) {
    @object[:userinfo] = (format_userinfo("") if @object[:user])
  }
end

#userinfo=(value) ⇒ RDF::URI

Returns self.

Parameters:

  • value (String, #to_s)

Returns:



1208
1209
1210
1211
1212
1213
1214
 
# File 'lib/rdf/model/uri.rb', line 1208

def userinfo=(value)
  object.delete_if {|k, v| %i(user password authority).include?(k)}
  object[:userinfo] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
  user; password; authority
  @value = nil
  self
end

#valid? ⇒ Boolean

Determine if the URI is a valid according to RFC3987

Note that RDF URIs syntactically can contain Unicode escapes, which are unencoded in the internal representation. To validate, %-encode specifically excluded characters from IRIREF

Returns:

  • (Boolean) —

    ‘true` or `false`

Since:

  • 0.3.9



370
371
372
 
# File 'lib/rdf/model/uri.rb', line 370

def valid?
  RDF::URI::IRI.match?(to_s) || false
end

#validate! ⇒ RDF::URI

Validates this URI, raising an error if it is invalid.

Returns:

Raises:

  • (ArgumentError) —

    if the URI is invalid

Since:

  • 0.3.0



380
381
382
383
 
# File 'lib/rdf/model/uri.rb', line 380

def validate!
  raise ArgumentError, "#{to_base.inspect} is not a valid IRI" if invalid?
  self
end

#value ⇒ String

lexical representation of URI, either absolute or relative

Returns:

  • (String) 


853
854
855
856
857
858
859
860
861
862
 
# File 'lib/rdf/model/uri.rb', line 853

def value
  return @value if @value
  @value = [
    ("#{scheme}:" if absolute?),
    ("//#{authority}" if authority),
    path,
    ("?#{query}" if query),
    ("##{fragment}" if fragment)
  ].compact.join("").freeze
end