Class: JSON::LD::Context::TermDefinition

Inherits:
Object
  • Object
show all
Defined in:
vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb

Overview

Term Definitions specify how properties and values have to be interpreted as well as the current vocabulary mapping and the default language

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(term, id: nil, index: nil, type_mapping: nil, container_mapping: nil, language_mapping: nil, direction_mapping: nil, reverse_property: false, nest: nil, protected: nil, simple: false, prefix: nil, context: nil) ⇒ TermDefinition

Create a new Term Mapping with an ID

Parameters:

  • term (String)
  • id (String) (defaults to: nil)
  • type_mapping (String) (defaults to: nil) —

    Type mapping

  • container_mapping (Set<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>) (defaults to: nil)
  • language_mapping (String) (defaults to: nil) —

    Language mapping of term, false is used if there is an explicit language mapping for this term

  • direction_mapping ("ltr", "rtl") (defaults to: nil) —

    Direction mapping of term, false is used if there is an explicit direction mapping for this term

  • reverse_property (Boolean) (defaults to: false)
  • protected (Boolean) (defaults to: nil) —

    mark resulting context as protected

  • nest (String) (defaults to: nil) —

    term used for nest properties

  • simple (Boolean) (defaults to: false) —

    This is a simple term definition, not an expanded term definition

  • prefix (Boolean) (defaults to: nil) —

    Term may be used as a prefix



2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2176

def initialize(term,
               id: nil,
               index: nil,
               type_mapping: nil,
               container_mapping: nil,
               language_mapping: nil,
               direction_mapping: nil,
               reverse_property: false,
               nest: nil,
               protected: nil,
               simple: false,
               prefix: nil,
               context: nil)
  @term                   = term
  @id                     = id.to_s           unless id.nil?
  @index                  = index.to_s        unless index.nil?
  @type_mapping           = type_mapping.to_s unless type_mapping.nil?
  self.container_mapping  = container_mapping
  @language_mapping       = language_mapping  unless language_mapping.nil?
  @direction_mapping      = direction_mapping unless direction_mapping.nil?
  @reverse_property       = reverse_property
  @protected              = protected
  @nest                   = nest unless nest.nil?
  @simple                 = simple
  @prefix                 = prefix            unless prefix.nil?
  @context                = context           unless context.nil?
end

Instance Attribute Details

#container_mapping ⇒ Array<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>

Base container mapping, without @set

Returns:



2113
2114
2115
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2113

def container_mapping
  @container_mapping
end

#context ⇒ Hash{String => Object}

Term-specific context

Returns:



2142
2143
2144
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2142

def context
  @context
end

#direction_mapping ⇒ "ltr", "rtl"

Direction of term, false is used if there is explicit direction mapping mapping for this term.

Returns:

  • ("ltr", "rtl") —

    direction_mapping



2124
2125
2126
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2124

def direction_mapping
  @direction_mapping
end

#id ⇒ RDF::URI

Returns IRI map.

Returns:



2103
2104
2105
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2103

def id
  @id
end

#index ⇒ Boolean

Property used for data indexing; defaults to @index

Returns:

  • (Boolean) 


2135
2136
2137
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2135

def index
  @index
end

#language_mapping ⇒ String

Language mapping of term, false is used if there is an explicit language mapping for this term.

Returns:

  • (String) —

    Language mapping



2120
2121
2122
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2120

def language_mapping
  @language_mapping
end

#nest ⇒ String

Returns Term used for nest properties.

Returns:

  • (String) —

    Term used for nest properties



2116
2117
2118
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2116

def nest
  @nest
end

#prefix=(value) ⇒ Object (writeonly)

Indicate that term may be used as a prefix



2138
2139
2140
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2138

def prefix=(value)
  @prefix = value
end

#protected=(value) ⇒ Boolean (writeonly)

Term is protected.

Returns:

  • (Boolean) 


2146
2147
2148
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2146

def protected=(value)
  @protected = value
end

#reverse_property ⇒ Boolean

Returns Reverse Property.

Returns:

  • (Boolean) —

    Reverse Property



2127
2128
2129
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2127

def reverse_property
  @reverse_property
end

#simple ⇒ Boolean

This is a simple term definition, not an expanded term definition

Returns:

  • (Boolean) 


2131
2132
2133
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2131

def simple
  @simple
end

#term ⇒ String

Returns term name.

Returns:



2106
2107
2108
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2106

def term
  @term
end

#type_mapping ⇒ String

Returns Type mapping.

Returns:



2109
2110
2111
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2109

def type_mapping
  @type_mapping
end

Instance Method Details

#==(other) ⇒ Boolean

Check if term definitions are identical, modulo @protected

Returns:

  • (Boolean) 


2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2315

def ==(other)
  other.is_a?(TermDefinition) &&
    id == other.id &&
    term == other.term &&
    type_mapping == other.type_mapping &&
    container_mapping == other.container_mapping &&
    nest == other.nest &&
    language_mapping == other.language_mapping &&
    direction_mapping == other.direction_mapping &&
    reverse_property == other.reverse_property &&
    index == other.index &&
    context == other.context &&
    prefix? == other.prefix? &&
    as_set? == other.as_set?
end

#as_set? ⇒ Boolean

If container mapping was defined along with @set

Returns:

  • (Boolean) 


2309
2310
2311
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2309

def as_set?
  @as_set || false
end

#inspect ⇒ Object 



2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2331

def inspect
  v = %w([TD)
  v << "id=#{@id}"
  v << "index=#{index.inspect}" unless index.nil?
  v << "term=#{@term}"
  v << "rev" if reverse_property
  v << "container=#{container_mapping}" if container_mapping
  v << "as_set=#{as_set?.inspect}"
  v << "lang=#{language_mapping.inspect}" unless language_mapping.nil?
  v << "dir=#{direction_mapping.inspect}" unless direction_mapping.nil?
  v << "type=#{type_mapping}" unless type_mapping.nil?
  v << "nest=#{nest.inspect}" unless nest.nil?
  v << "simple=true" if @simple
  v << "protected=true" if @protected
  v << "prefix=#{@prefix.inspect}" unless @prefix.nil?
  v << "has-context" unless context.nil?
  v.join(" ") + "]"
end

#match_compact_iri?(iri) ⇒ Boolean

Returns true if the term matches a compact IRI

Parameters:

  • iri (String) —

    the compact IRI

Returns:

  • (Boolean) 


2222
2223
2224
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2222

def match_compact_iri?(iri)
  iri.start_with?(prefix_colon)
end

#match_iri?(iri) ⇒ Boolean

Returns true if the term matches a IRI

Parameters:

Returns:

  • (Boolean) 


2214
2215
2216
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2214

def match_iri?(iri)
  iri.start_with?(id)
end

#prefix? ⇒ Boolean

This is an appropriate term to use as the prefix of a compact IRI

Returns:

  • (Boolean) —

    simple



2156
2157
2158
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2156

def prefix?
  @prefix
end

#protected? ⇒ Boolean

Term is protected.

Returns:

  • (Boolean) 


2206
2207
2208
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2206

def protected?
  !!@protected
end

#simple? ⇒ Boolean

This is a simple term definition, not an expanded term definition

Returns:

  • (Boolean) —

    simple



2150
2151
2152
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2150

def simple?
  simple
end

#to_context_definition(context) ⇒ String, Hash{String => Array[String], String}

Output Hash or String definition for this definition considering @language and @vocab

Parameters:

Returns:



2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2249

def to_context_definition(context)
  cid = if context.vocab && id.start_with?(context.vocab)
    # Nothing to return unless it's the same as the vocab
    id == context.vocab ? context.vocab : id.to_s[context.vocab.length..]
  else
    # Find a term to act as a prefix
    iri, prefix = context.iri_to_term.detect { |i, _p| id.to_s.start_with?(i.to_s) }
    iri && iri != id ? "#{prefix}:#{id.to_s[iri.length..]}" : id
  end

  if simple?
    cid.to_s unless cid == term && context.vocab
  else
    defn = {}
    defn[reverse_property ? '@reverse' : '@id'] = cid.to_s unless cid == term && !reverse_property
    if type_mapping
      defn['@type'] = if KEYWORDS.include?(type_mapping)
        type_mapping
      else
        context.compact_iri(type_mapping, vocab: true)
      end
    end

    cm = Array(container_mapping)
    cm << "@set" if as_set? && !cm.include?("@set")
    cm = cm.first if cm.length == 1
    defn['@container'] = cm unless cm.empty?
    # Language set as false to be output as null
    defn['@language'] = (@language_mapping || nil) unless @language_mapping.nil?
    defn['@direction'] = (@direction_mapping || nil) unless @direction_mapping.nil?
    defn['@context'] = @context if @context
    defn['@nest'] = @nest if @nest
    defn['@index'] = @index if @index
    defn['@prefix'] = @prefix unless @prefix.nil?
    defn
  end
end

#to_rb ⇒ String

Turn this into a source for a new instantiation FIXME: context serialization

Returns:



2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
 
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/json-ld-cb5ef847d963/lib/json/ld/context.rb', line 2291

def to_rb
  defn = [%(TermDefinition.new\(#{term.inspect})]
  %w[id index type_mapping container_mapping language_mapping direction_mapping reverse_property nest simple
     prefix context protected].each do |acc|
    v = instance_variable_get("@#{acc}".to_sym)
    v = v.to_s if v.is_a?(RDF::Term)
    if acc == 'container_mapping'
      v = v.to_a
      v << '@set' if as_set?
      v = v.first if v.length <= 1
    end
    defn << "#{acc}: #{v.inspect}" if v
  end
  defn.join(', ') + ")"
end