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

Inherits:
Object
  • Object
show all
Defined in:
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



2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
 
# File 'lib/json/ld/context.rb', line 2069

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:



2010
2011
2012
 
# File 'lib/json/ld/context.rb', line 2010

def container_mapping
  @container_mapping
end

#context ⇒ Hash{String => Object}

Term-specific context

Returns:

  • (Hash{String => Object}) 


2039
2040
2041
 
# File 'lib/json/ld/context.rb', line 2039

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



2021
2022
2023
 
# File 'lib/json/ld/context.rb', line 2021

def direction_mapping
  @direction_mapping
end

#id ⇒ RDF::URI

Returns IRI map.

Returns:



2000
2001
2002
 
# File 'lib/json/ld/context.rb', line 2000

def id
  @id
end

#index ⇒ Boolean

Property used for data indexing; defaults to @index

Returns:

  • (Boolean) 


2032
2033
2034
 
# File 'lib/json/ld/context.rb', line 2032

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



2017
2018
2019
 
# File 'lib/json/ld/context.rb', line 2017

def language_mapping
  @language_mapping
end

#nest ⇒ String

Returns Term used for nest properties.

Returns:

  • (String) —

    Term used for nest properties



2013
2014
2015
 
# File 'lib/json/ld/context.rb', line 2013

def nest
  @nest
end

#prefix=(value) ⇒ Object (writeonly)

Indicate that term may be used as a prefix



2035
2036
2037
 
# File 'lib/json/ld/context.rb', line 2035

def prefix=(value)
  @prefix = value
end

#protected=(value) ⇒ Boolean (writeonly)

Term is protected.

Returns:

  • (Boolean) 


2043
2044
2045
 
# File 'lib/json/ld/context.rb', line 2043

def protected=(value)
  @protected = value
end

#reverse_property ⇒ Boolean

Returns Reverse Property.

Returns:

  • (Boolean) —

    Reverse Property



2024
2025
2026
 
# File 'lib/json/ld/context.rb', line 2024

def reverse_property
  @reverse_property
end

#simple ⇒ Boolean

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

Returns:

  • (Boolean) 


2028
2029
2030
 
# File 'lib/json/ld/context.rb', line 2028

def simple
  @simple
end

#term ⇒ String

Returns term name.

Returns:

  • (String) —

    term name



2003
2004
2005
 
# File 'lib/json/ld/context.rb', line 2003

def term
  @term
end

#type_mapping ⇒ String

Returns Type mapping.

Returns:

  • (String) —

    Type mapping



2006
2007
2008
 
# File 'lib/json/ld/context.rb', line 2006

def type_mapping
  @type_mapping
end

Instance Method Details

#==(other) ⇒ Boolean

Check if term definitions are identical, modulo @protected

Returns:

  • (Boolean) 


2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
 
# File 'lib/json/ld/context.rb', line 2187

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 &&
  simple == other.simple &&
  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) 


2183
 
# File 'lib/json/ld/context.rb', line 2183

def as_set?; @as_set || false; end

#inspect ⇒ Object 



2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
 
# File 'lib/json/ld/context.rb', line 2204

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

#prefix? ⇒ Boolean

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

Returns:

  • (Boolean) —

    simple



2051
 
# File 'lib/json/ld/context.rb', line 2051

def prefix?; @prefix; end

#protected? ⇒ Boolean

Term is protected.

Returns:

  • (Boolean) 


2099
 
# File 'lib/json/ld/context.rb', line 2099

def protected?; !!@protected; end

#simple? ⇒ Boolean

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

Returns:

  • (Boolean) —

    simple



2047
 
# File 'lib/json/ld/context.rb', line 2047

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:

  • (String, Hash{String => Array[String], String}) 


2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
 
# File 'lib/json/ld/context.rb', line 2124

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..-1]
  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..-1]}" : 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 ? @language_mapping : nil) unless @language_mapping.nil?
    defn['@direction'] = (@direction_mapping ? @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:

  • (String) 


2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
 
# File 'lib/json/ld/context.rb', line 2166

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