Module: RDF::Vocabulary::Term

Includes:
Resource
Defined in:
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.

Term attributes can also be accessed using #properties where the attribute values are transformed into different types of RDF::Value. Properties can be indexed by key, where a key is defined (See ATTR_URIs), absolute URI, or PName, where the prefix is associated with a loaded vocabulary.

Constant Summary collapse

ATTR_URIs =

Look up URIs for attribute symbols

Returns:

{
  allValuesFrom:      RDF::URI("http://www.w3.org/2002/07/owl#allValuesFrom"),
  altLabel:           RDF::URI("http://www.w3.org/2004/02/skos/core#altLabel"),
  broader:            RDF::URI("http://www.w3.org/2004/02/skos/core#broader"),
  cardinality:        RDF::URI("http://www.w3.org/2002/07/owl#cardinality"),
  comment:            RDF::URI("http://www.w3.org/2000/01/rdf-schema#comment"),
  definition:         RDF::URI("http://www.w3.org/2004/02/skos/core#definition"),
  domain:             RDF::URI("http://www.w3.org/2000/01/rdf-schema#domain"),
  domainIncludes:     RDF::URI("http://schema.org/domainIncludes"),
  editorialNote:      RDF::URI("http://www.w3.org/2004/02/skos/core#editorialNote"),
  equivalentClass:    RDF::URI("http://www.w3.org/2002/07/owl#equivalentClass"),
  equivalentProperty: RDF::URI("http://www.w3.org/2002/07/owl#equivalentProperty"),
  exactMatch:         RDF::URI("http://www.w3.org/2004/02/skos/core#exactMatch"),
  hasTopConcept:      RDF::URI("http://www.w3.org/2004/02/skos/core#hasTopConcept"),
  inScheme:           RDF::URI("http://www.w3.org/2004/02/skos/core#inScheme"),
  intersectionOf:     RDF::URI("http://www.w3.org/2002/07/owl#intersectionOf"),
  inverseOf:          RDF::URI("http://www.w3.org/2002/07/owl#inverseOf"),
  isDefinedBy:        RDF::URI("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
  label:              RDF::URI("http://www.w3.org/2000/01/rdf-schema#label"),
  maxCardinality:     RDF::URI("http://www.w3.org/2002/07/owl#maxCardinality"),
  member:             RDF::URI("http://www.w3.org/2004/02/skos/core#member"),
  minCardinality:     RDF::URI("http://www.w3.org/2002/07/owl#minCardinality"),
  narrower:           RDF::URI("http://www.w3.org/2004/02/skos/core#narrower"),
  notation:           RDF::URI("http://www.w3.org/2004/02/skos/core#notation"),
  note:               RDF::URI("http://www.w3.org/2004/02/skos/core#note"),
  onProperty:         RDF::URI("http://www.w3.org/2002/07/owl#onProperty"),
  prefLabel:          RDF::URI("http://www.w3.org/2004/02/skos/core#prefLabel"),
  range:              RDF::URI("http://www.w3.org/2000/01/rdf-schema#range"),
  rangeIncludes:      RDF::URI("http://schema.org/rangeIncludes"),
  related:            RDF::URI("http://www.w3.org/2004/02/skos/core#related"),
  someValuesFrom:     RDF::URI("http://www.w3.org/2002/07/owl#someValuesFrom"),
  subClassOf:         RDF::URI("http://www.w3.org/2000/01/rdf-schema#subClassOf"),
  subPropertyOf:      RDF::URI("http://www.w3.org/2000/01/rdf-schema#subPropertyOf"),
  type:               RDF::URI("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
  unionOf:            RDF::URI("http://www.w3.org/2002/07/owl#unionOf"),
}.freeze
URI_ATTRs =

Look up attribute symbols from URIs

Returns:

ATTR_URIs.invert.freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Resource

#resource?

Methods included from Term

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

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?

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


1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
# File 'lib/rdf/vocabulary.rb', line 1263

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,
       :imports, :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

#allValuesFromArray<Term> (readonly)

owl:allValuesFrom accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#altLabelLiteral+ (readonly)

skos:altLabel accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#attributesHash{Symbol,Resource => Term, #to_s} (readonly)

Note:

lookup by PName is DEPRECATED and will be removed in a future version.

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

Attributes are indexed by symbol. Symbols directly interpreted by a term are the accessors defined for the RDF::Vocabulary::Term class, also in ATTR_URIs. Other keys are interpreted as absolute URIs or PNames for properties defined on this term.

Symbols which are accessors may also be looked up by their associated URI.

Examples:

looking up term label

RDF::RDFS.Literal.attributes[:label] #=> "Literal"
RDF::RDFS.Literal.attributes[:"rdfs:label"] #=> "Literal"
RDF::RDFS.Literal.attributes[RDF::RDFS.label] #=> "Literal"
RDF::RDFS.Literal.attributes["http://www.w3.org/2000/01/rdf-schema#label"] #=> "Literal"
RDF::RDFS.Literal.attributes[:"http://www.w3.org/2000/01/rdf-schema#label"] #=> "Literal"

Returns:


949
950
951
# File 'lib/rdf/vocabulary.rb', line 949

def attributes
  @attributes
end

#broaderArray<Term> (readonly)

skos:broader accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#cardinalityArray<Literal> (readonly)

owl:cardinality accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#commentLiteral+ (readonly)

rdfs:comment accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 822

#definitionLiteral+ (readonly)

skos:definition accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#domainArray<Term> (readonly)

rdfs:domain accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 822

#domainIncludesArray<Term> (readonly)

schema:domainIncludes accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 881

#editorialNoteLiteral+ (readonly)

skos:editorialNote accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#equivalentClassArray<Term> (readonly)

owl:equivalentClass accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#equivalentPropertyArray<Term> (readonly)

owl:equivalentProperty accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#exactMatchArray<Term> (readonly)

skos:exactMatch accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#hasTopConceptArray<Term> (readonly)

skos:hasTopConcept accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#inSchemeArray<Term> (readonly)

skos:inScheme accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#intersectionOfArray<Term> (readonly)

owl:intersectionOf accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#inverseOfArray<Term> (readonly)

owl:inverseOf accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#isDefinedByArray<Term> (readonly)

rdfs:isDefinedBy accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 822

#labelLiteral (readonly)

rdfs:label accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 822

#maxCardinalityArray<Literal> (readonly)

owl:maxCardinality accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#memberArray<Term> (readonly)

skos:member accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#minCardinalityArray<Literal> (readonly)

owl:minCardinality accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#narrowerArray<Term> (readonly)

skos:narrower accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#notationLiteral+ (readonly)

skos:notation accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#noteLiteral+ (readonly)

skos:note accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#onPropertyArray<Term> (readonly)

owl:onProperty accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#prefLabelLiteral (readonly)

skos:prefLabel accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#rangeArray<Term> (readonly)

rdfs:range accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 822

#rangeIncludesArray<Term> (readonly)

schema:rangeIncludes accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 881

skos:related accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 888

#someValuesFromArray<Term> (readonly)

owl:someValuesFrom accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#subClassOfArray<Term> (readonly)

rdfs:subClassOf accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 822

#subPropertyOfArray<Term> (readonly)

rdfs:subPropertyOf accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 822

#typeArray<Term> (readonly)

rdf:type accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 822

#unionOfList<Term>, Array<Term> (readonly)

owl:unionOf accessor

Returns:


# File 'lib/rdf/vocabulary.rb', line 847

#vocabRDF::Vocabulary (readonly)

Vocabulary of this term.

Returns:


932
933
934
# File 'lib/rdf/vocabulary.rb', line 932

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


1025
1026
1027
# File 'lib/rdf/vocabulary.rb', line 1025

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:

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

    Parameters:

    • uri (URI, String, #to_s)
    • vocab (Vocabulary)

      Vocabulary of this term.

    • attributes (Hash{Symbol => Symbol,Array<String,Term>}) (defaults to: )

      ({}) Attributes of this vocabulary term, used for finding label and comment and to serialize the term back to RDF. See #attributes and #properties for other ways to access.

    • options (Hash{Symbol => Object})

      Options from URI#initialize

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

    Parameters:

    • options (Hash{Symbol => Object})
    • vocab (Vocabulary)

      Vocabulary of this term.

    • attributes (Hash{Symbol => Symbol,Array<String,Term>}) (defaults to: )

      ({}) Attributes of this vocabulary term, used for finding label and comment and to serialize the term back to RDF. See #attributes and #properties for other ways to access.

    • options (Hash{Symbol => Object})

      Options from URI#initialize


967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
# File 'lib/rdf/vocabulary.rb', line 967

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

  # Create default proc on attributes to allow lookup by different key types.
  attributes = attributes.dup if attributes.frozen?
  attributes.default_proc = -> (hash, key) do
    sym = case key
    when RDF::URI
      URI_ATTRs.fetch(key, key.to_s.to_sym)
    when String
      URI_ATTRs.fetch(RDF::URI(key), key.to_s.to_sym)
    when Symbol
      case key.to_s
      when /^https?:/
        # Lookup by associated attribute, or pname
        URI_ATTRs.fetch(RDF::URI(key.to_s), RDF::URI(key).pname.to_sym)
      when /:/
        uri = RDF::Vocabulary.expand_pname(key)
        # Lookup by associated attribute or URI
        URI_ATTRs.fetch(uri, uri.to_s.to_sym)
      end
    end
    hash.fetch(sym, nil)
  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:

  • prop (Symbol)

Returns:


1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
# File 'lib/rdf/vocabulary.rb', line 1113

def attribute_value(prop)
  values = attributes[prop]
  return nil if values.nil?
  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)

1053
1054
1055
# File 'lib/rdf/vocabulary.rb', line 1053

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

#datatype?Boolean

Is this a class term?

Returns:

  • (Boolean)

1067
1068
1069
# File 'lib/rdf/vocabulary.rb', line 1067

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

#domain_includesRDF::URI

Accessor for schema:domainIncludes

Returns:


1214
1215
1216
# File 'lib/rdf/vocabulary.rb', line 1214

def domain_includes
  domainIncludes
end

#dupRDF::URI

Returns a duplicate copy of self.

Returns:


1033
1034
1035
1036
1037
1038
# File 'lib/rdf/vocabulary.rb', line 1033

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:


1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
# File 'lib/rdf/vocabulary.rb', line 1152

def each_statement
  attributes.keys.each do |p|
    prop = ATTR_URIs.fetch(p) { RDF::Vocabulary::expand_pname(p)}
    values = attribute_value(p)
    values = [values].compact unless values.is_a?(Array)
    values.each do |value|
      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
    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

1172
1173
1174
1175
1176
1177
1178
# File 'lib/rdf/vocabulary.rb', line 1172

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

#inspectString

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

Returns:

  • (String)

    The URI object's state, as a String.


1185
1186
1187
# File 'lib/rdf/vocabulary.rb', line 1185

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)

1081
1082
1083
# File 'lib/rdf/vocabulary.rb', line 1081

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

#propertiesHash{Symbol => Array<RDF::Value>}

Note:

lookup by PName is DEPRECATED and will be removed in a future version.

Enumerate attributes with values transformed into RDF::Value instances Uses an empty hash with a default_proc which looks up values in attributes.

Properties are indexed by symbol. Symbols directly interpreted by a term are the accessors defined for the RDF::Vocabulary::Term class, also in ATTR_URIs. Other keys are interpreted as absolute URIs or PNames for properties defined on this term.

Symbols which are accessors may also be looked up by their associated URI.

Examples:

looking up term label

RDF::RDFS.Literal.label #=> RDF::Literal("Literal")
RDF::RDFS.Literal.properties[:label] #=> RDF::Literal("Literal")
RDF::RDFS.Literal.properties[:"rdfs:label"] #=> RDF::Literal("Literal")
RDF::RDFS.Literal.properties[RDF::RDFS.label] #=> RDF::Literal("Literal")
RDF::RDFS.Literal.properties["http://www.w3.org/2000/01/rdf-schema#label"] #=> RDF::Literal("Literal")
RDF::RDFS.Literal.properties[:"http://www.w3.org/2000/01/rdf-schema#label"] #=> RDF::Literal("Literal")

Returns:


1104
1105
1106
# File 'lib/rdf/vocabulary.rb', line 1104

def properties
  Hash.new {|hash, key| attribute_value(key)}
end

#property?Boolean

Is this a class term?

Returns:

  • (Boolean)

1060
1061
1062
# File 'lib/rdf/vocabulary.rb', line 1060

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

#range_includesRDF::URI

Accessor for schema:rangeIncludes

Returns:


1220
1221
1222
# File 'lib/rdf/vocabulary.rb', line 1220

def range_includes
  rangeIncludes
end

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

Implement accessor to symbol attributes

Returns:

  • (Boolean)

1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
# File 'lib/rdf/vocabulary.rb', line 1190

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.key?(method)
  else
    super
  end
end

#restriction?Boolean

Is this a Restriction term?

Returns:

  • (Boolean)

1074
1075
1076
# File 'lib/rdf/vocabulary.rb', line 1074

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:


1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
# File 'lib/rdf/vocabulary.rb', line 1227

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


1045
1046
1047
1048
# File 'lib/rdf/vocabulary.rb', line 1045

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