Module: RDF::Vocabulary::Term

Includes:
Resource
Defined in:
vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb

Overview

A Vocabulary Term is a Resource that can also act as an Enumerable to generate the RDF definition of vocabulary terms as defined within the vocabulary definition.

Terms include attributes where values a embedded resources, lists or other terms. This allows, for example, navigation of a concept heirarchy.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Resource

#resource?

Methods included from Term

#<=>, #==, #aggregate?, #compatible?, #eql?, #escape, #evaluate, #ndvars, #optimize, #term?, #to_base, #to_term, #vars

Methods included from RDF::Value

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

Methods included from SPARQL::Algebra::Expression

cast, #constant?, #evaluate, extension, extensions, for, #invalid?, #node?, open, #optimize, #optimize!, parse, register_extension, #to_sxp_bin, #validate!, #variable?

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ Object (protected)

Implement accessor to symbol attributes



1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 1179

def method_missing(method, *args, &block)
  case method
  when :comment, :notation, :note, :editorialNote, :definition
    attribute_value(method)
  when :label, :altLabel, :prefLabel
    # Defaults to URI fragment or path tail
    begin
      attribute_value(method)
    rescue KeyError
      to_s.split(/[\/\#]/).last
    end
  when :type, :subClassOf, :subPropertyOf, :domain, :range, :isDefinedBy,
       :allValuesFrom, :cardinality, :equivalentClass, :equivalentProperty,
       :intersectionOf, :inverseOf, :maxCardinality, :minCardinality,
       :onProperty, :someValuesFrom, :unionOf,
       :domainIncludes, :rangeIncludes,
       :broader, :exactMatch, :hasTopConcept, :inScheme, :member, :narrower, :related

    # Return value as an Array, unless it is a list
    case value = attribute_value(method)
    when Array, RDF::List then value
    else [value].compact
    end
  else
    super
  end
end

Instance Attribute Details

#allValuesFrom ⇒ Array<Term> (readonly)

owl:allValuesFrom accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#altLabel ⇒ Literal+ (readonly)

skos:altLabel accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#attributes ⇒ Hash{Symbol,Resource => Term, #to_s} (readonly)

Attributes of this vocabulary term, used for finding label and comment and to serialize the term back to RDF.

Returns:



878
879
880
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 878

def attributes
  @attributes
end

#broader ⇒ Array<Term> (readonly)

skos:broader accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#cardinality ⇒ Array<Literal> (readonly)

owl:cardinality accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#comment ⇒ Literal+ (readonly)

rdfs:comment accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 764

#definition ⇒ Literal+ (readonly)

skos:definition accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#domain ⇒ Array<Term> (readonly)

rdfs:domain accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 764

#domainIncludes ⇒ Array<Term> (readonly)

schema:domainIncludes accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 823

#editorialNote ⇒ Literal+ (readonly)

skos:editorialNote accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#equivalentClass ⇒ Array<Term> (readonly)

owl:equivalentClass accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#equivalentProperty ⇒ Array<Term> (readonly)

owl:equivalentProperty accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#exactMatch ⇒ Array<Term> (readonly)

skos:exactMatch accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#hasTopConcept ⇒ Array<Term> (readonly)

skos:hasTopConcept accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#inScheme ⇒ Array<Term> (readonly)

skos:inScheme accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#intersectionOf ⇒ Array<Term> (readonly)

owl:intersectionOf accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#inverseOf ⇒ Array<Term> (readonly)

owl:inverseOf accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#isDefinedBy ⇒ Array<Term> (readonly)

rdfs:isDefinedBy accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 764

#label ⇒ Literal (readonly)

rdfs:label accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 764

#maxCardinality ⇒ Array<Literal> (readonly)

owl:maxCardinality accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#member ⇒ Array<Term> (readonly)

skos:member accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#minCardinality ⇒ Array<Literal> (readonly)

owl:minCardinality accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#narrower ⇒ Array<Term> (readonly)

skos:narrower accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#notation ⇒ Literal+ (readonly)

skos:notation accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#note ⇒ Literal+ (readonly)

skos:note accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#onProperty ⇒ Array<Term> (readonly)

owl:onProperty accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#prefLabel ⇒ Literal (readonly)

skos:prefLabel accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#range ⇒ Array<Term> (readonly)

rdfs:range accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 764

#rangeIncludes ⇒ Array<Term> (readonly)

schema:rangeIncludes accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 823

#related ⇒ Array<Term> (readonly)

skos:related accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 830

#someValuesFrom ⇒ Array<Term> (readonly)

owl:someValuesFrom accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#subClassOf ⇒ Array<Term> (readonly)

rdfs:subClassOf accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 764

#subPropertyOf ⇒ Array<Term> (readonly)

rdfs:subPropertyOf accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 764

#type ⇒ Array<Term> (readonly)

rdf:type accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 764

#unionOf ⇒ List<Term>, Array<Term> (readonly)

owl:unionOf accessor

Returns:




# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 789

#vocab ⇒ RDF::Vocabulary (readonly)

Vocabulary of this term.

Returns:



874
875
876
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 874

def vocab
  @vocab
end

Class Method Details

.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.

Parameters:

Returns:

  • (RDF::URI) —

    an immutable, frozen URI object



931
932
933
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 931

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

.new(uri, attributes: , **options) ⇒ Object .new(attributes: , **options) ⇒ Object

Overloads:



896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 896

def self.new(*args, vocab: nil, attributes: {}, **options)
  klass = if args.first.nil?
    RDF::Node
  elsif args.first.is_a?(Hash)
    args.unshift(nil)
    RDF::Node
  elsif args.first.to_s.start_with?("_:")
    args = args[1..-1].unshift($1)
    RDF::Node
  else RDF::URI
  end
  term = klass.allocate.extend(Term)
  term.send(:initialize, *args)
  term.instance_variable_set(:@vocab, vocab)
  term.instance_variable_set(:@attributes, attributes)
  term
end

Instance Method Details

#attribute_value(prop) ⇒ RDF::Value+

Values of an attributes as RDF::Value

Parameters:

Returns:



1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 1006

def attribute_value(prop)
  values = attributes[prop]
  values = [values].compact unless values.is_a?(Array)
  prop_values = values.map do |value|
    v = value.is_a?(Symbol) ? value.to_s : value
    value = (RDF::Vocabulary.expand_pname(v) rescue nil) if v.is_a?(String) && v.include?(':')
    value = value.to_uri if value.respond_to?(:to_uri)
    unless value.is_a?(RDF::Value) && value.valid?
      # Use as most appropriate literal
      value = [
        RDF::Literal::Date,
        RDF::Literal::DateTime,
        RDF::Literal::Integer,
        RDF::Literal::Decimal,
        RDF::Literal::Double,
        RDF::Literal::Boolean,
        RDF::Literal
      ].inject(nil) do |m, klass|
        m || begin
          l = klass.new(v)
          l if l.valid?
        end
      end
    end

    value
  end

  prop_values.length <= 1 ? prop_values.first : prop_values
end

#class? ⇒ Boolean

Is this a class term?

Returns:

  • (Boolean) 


959
960
961
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 959

def class?
  Array(self.type).any? {|t| t.to_s.include?('Class')}
end

#datatype? ⇒ Boolean

Is this a class term?

Returns:

  • (Boolean) 


973
974
975
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 973

def datatype?
  Array(self.type).any? {|t| t.to_s.include?('Datatype')}
end

#domain_includes ⇒ RDF::URI

Accessor for schema:domainIncludes

Returns:



1128
1129
1130
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 1128

def domain_includes
  domainIncludes
end

#dup ⇒ RDF::URI

Returns a duplicate copy of self.

Returns:



939
940
941
942
943
944
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 939

def dup
  term = super.extend(Term)
  term.instance_variable_set(:@vocab, vocab)
  term.instance_variable_set(:@attributes, attributes)
  term
end

#each_statement {|| ... } ⇒ Object

Enumerate each statement constructed from the defined vocabulary terms

If a property value is known to be a URI, or expands to a URI, the object is a URI, otherwise, it will be a Literal.

Yields:

  • statement

Yield Parameters:



1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 1044

def each_statement
  attributes.keys.each do |p|
    values = attribute_value(p)
    values = [values].compact unless values.is_a?(Array)
    values.each do |value|
      begin
        prop = case p
        when :type
          RDF::RDFV[p]
        when :subClassOf, :subPropertyOf, :domain, :range, :isDefinedBy, :label, :comment
          RDF::RDFS[p]
        when :allValuesFrom, :cardinality, :equivalentClass, :equivalentProperty,
             :intersectionOf, :inverseOf, :maxCardinality, :minCardinality,
             :onProperty, :someValuesFrom, :unionOf
          RDF::OWL[p]
        when :domainIncludes, :rangeIncludes
          RDF::Vocabulary.find_term("http://schema.org/#{p}")
        when :broader, :definition, :exactMatch, :hasTopConcept, :inScheme,
             :member, :narrower, :related, :altLabel, :editorialNote,
             :notation, :note, :prefLabel
          RDF::Vocabulary.find_term("http://www.w3.org/2004/02/skos/core##{p}")
        else
          RDF::Vocabulary.expand_pname(p)
        end

        yield RDF::Statement(self, prop, value) if prop.is_a?(RDF::URI)

        # Enumerate over value statements, if enumerable
        if value.is_a?(RDF::Enumerable) || (value.is_a?(Term) && value.node?)
          value.each_statement {|s| yield s}
        end
      rescue KeyError
        # Skip things eroneously defined in the vocabulary
      end
    end
  end
end

#enum_for(method = :each_statement, *args) ⇒ RDF::Enumerable::Enumerator Also known as: to_enum

Return an enumerator over Statement defined for this vocabulary.

Returns:

See Also:

  • Object#enum_for


1086
1087
1088
1089
1090
1091
1092
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 1086

def enum_for(method = :each_statement, *args)
  # Ensure that enumerators are, themselves, queryable
  this = self
  Enumerable::Enumerator.new do |yielder|
    this.send(method, *args) {|*y| yielder << (y.length > 1 ? y : y.first)}
  end
end

#inspect ⇒ String

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

Returns:

  • (String) —

    The URI object's state, as a String.



1099
1100
1101
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 1099

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

#other? ⇒ Boolean

Is this neither a class, property or datatype term?

Returns:

  • (Boolean) 


987
988
989
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 987

def other?
  Array(self.type).none? {|t| t.to_s.match?(/(Class|Property|Datatype|Restriction)/)}
end

#properties ⇒ Hash{Symbol => Array<RDF::Value>}

Enumerate attributes with values transformed into RDF::Value instances

Returns:



995
996
997
998
999
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 995

def properties
  attributes.keys.inject({}) do |memo, p|
    memo.merge(p => attribute_value(p))
  end
end

#property? ⇒ Boolean

Is this a class term?

Returns:

  • (Boolean) 


966
967
968
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 966

def property?
  Array(self.type).any? {|t| t.to_s.include?('Property')}
end

#range_includes ⇒ RDF::URI

Accessor for schema:rangeIncludes

Returns:



1134
1135
1136
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 1134

def range_includes
  rangeIncludes
end

#respond_to?(method, include_all = false) ⇒ Boolean

Implement accessor to symbol attributes

Returns:

  • (Boolean) 


1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 1104

def respond_to?(method, include_all = false)
  case method
  when :comment, :notation, :note, :editorialNote, :definition,
       :label, :altLabel, :prefLabel, :type, :isDefinedBy
    true
  when :subClassOf, :subPropertyOf,
       :domainIncludes, :rangeIncludes,
       :equivalentClass, :intersectionOf, :unionOf
    self.class?
  when :domain, :range, :equivalentProperty, :inverseOf
    self.property?
  when :allValuesFrom, :cardinality,
       :maxCardinality, :minCardinality,
       :onProperty, :someValuesFrom
    self.restriction?
  when :broader, :exactMatch, :hasTopConcept, :inScheme, :member, :narrower, :related
    @attributes.has_key?(method)
  else
    super
  end
end

#restriction? ⇒ Boolean

Is this a Restriction term?

Returns:

  • (Boolean) 


980
981
982
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 980

def restriction?
  Array(self.type).any? {|t| t.to_s.include?('Restriction')}
end

#to_ruby(indent: "") ⇒ String

Serialize back to a Ruby source initializer

Parameters:

  • indent (String) (defaults to: "")

Returns:



1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 1141

def to_ruby(indent: "")
  "term(" +
  (self.uri? ? self.to_s.inspect + ",\n" : "\n") +
  "#{indent}  " +
  attributes.keys.sort.map do |k|
    values = attribute_value(k)
    values = [values].compact unless values.is_a?(Array)
    values = values.map do |value|
      if value.is_a?(Literal) && %w(: comment definition notation note editorialNote).include?(k.to_s)
        "%(#{value.to_s.gsub('(', '\(').gsub(')', '\)')}).freeze"
      elsif value.is_a?(RDF::URI)
        "#{value.pname.inspect}.freeze"
      elsif value.is_a?(RDF::Vocabulary::Term)
        value.to_ruby(indent: indent + "  ")
      elsif value.is_a?(RDF::Term)
        "#{value.to_s.inspect}.freeze"
      elsif value.is_a?(RDF::List)
        list_elements = value.map do |u|
          if u.uri?
            "#{u.pname.inspect}.freeze"
          elsif u.respond_to?(:to_ruby)
            u.to_ruby(indent: indent + "  ")
          else
            "#{u.to_s.inspect}.freeze"
          end
        end
        "list(#{list_elements.join(', ')})"
      else
        "#{value.inspect}.freeze"
      end
    end
    "#{k.to_s.include?(':') ? k.to_s.inspect : k}: " +
    (values.length == 1 ? values.first : ('[' + values.join(',') + ']'))
  end.join(",\n#{indent}  ") + "\n#{indent})"
  
end

#valid? ⇒ Boolean

Determine if the URI is a valid according to RFC3987

Returns:

  • (Boolean) —

    true or false

Since:

  • 0.3.9



951
952
953
954
 
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-24ba7cdc342f/lib/rdf/vocabulary.rb', line 951

def valid?
  # Validate relative to RFC3987
  node? || RDF::URI::IRI.match?(to_s) || false
end