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



2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
 
# File 'lib/json/ld/context.rb', line 2063

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:



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

def container_mapping
  @container_mapping
end

#context ⇒ Hash{String => Object}

Term-specific context

Returns:

  • (Hash{String => Object}) 


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

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



2015
2016
2017
 
# File 'lib/json/ld/context.rb', line 2015

def direction_mapping
  @direction_mapping
end

#id ⇒ RDF::URI

Returns IRI map.

Returns:



1994
1995
1996
 
# File 'lib/json/ld/context.rb', line 1994

def id
  @id
end

#index ⇒ Boolean

Property used for data indexing; defaults to @index

Returns:

  • (Boolean) 


2026
2027
2028
 
# File 'lib/json/ld/context.rb', line 2026

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



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

def language_mapping
  @language_mapping
end

#nest ⇒ String

Returns Term used for nest properties.

Returns:

  • (String) —

    Term used for nest properties



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

def nest
  @nest
end

#prefix=(value) ⇒ Object (writeonly)

Indicate that term may be used as a prefix



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

def prefix=(value)
  @prefix = value
end

#protected=(value) ⇒ Boolean (writeonly)

Term is protected.

Returns:

  • (Boolean) 


2037
2038
2039
 
# File 'lib/json/ld/context.rb', line 2037

def protected=(value)
  @protected = value
end

#reverse_property ⇒ Boolean

Returns Reverse Property.

Returns:

  • (Boolean) —

    Reverse Property



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

def reverse_property
  @reverse_property
end

#simple ⇒ Boolean

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

Returns:

  • (Boolean) 


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

def simple
  @simple
end

#term ⇒ String

Returns term name.

Returns:

  • (String) —

    term name



1997
1998
1999
 
# File 'lib/json/ld/context.rb', line 1997

def term
  @term
end

#type_mapping ⇒ String

Returns Type mapping.

Returns:

  • (String) —

    Type mapping



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

def type_mapping
  @type_mapping
end

Instance Method Details

#==(other) ⇒ Boolean

Check if term definitions are identical, modulo @protected

Returns:

  • (Boolean) 


2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
 
# File 'lib/json/ld/context.rb', line 2181

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) 


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

def as_set?; @as_set || false; end

#inspect ⇒ Object 



2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
 
# File 'lib/json/ld/context.rb', line 2198

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



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

def prefix?; @prefix; end

#protected? ⇒ Boolean

Term is protected.

Returns:

  • (Boolean) 


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

def protected?; !!@protected; end

#simple? ⇒ Boolean

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

Returns:

  • (Boolean) —

    simple



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

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}) 


2118
2119
2120
2121
2122
2123
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
 
# File 'lib/json/ld/context.rb', line 2118

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) 


2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
 
# File 'lib/json/ld/context.rb', line 2160

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