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



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

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:



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

def container_mapping
  @container_mapping
end

#context ⇒ Hash{String => Object}

Term-specific context

Returns:

  • (Hash{String => Object}) 


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

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



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

def direction_mapping
  @direction_mapping
end

#id ⇒ RDF::URI

Returns IRI map.

Returns:



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

def id
  @id
end

#index ⇒ Boolean

Property used for data indexing; defaults to @index

Returns:

  • (Boolean) 


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

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



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

def language_mapping
  @language_mapping
end

#nest ⇒ String

Returns Term used for nest properties.

Returns:

  • (String) —

    Term used for nest properties



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

def nest
  @nest
end

#prefix=(value) ⇒ Object (writeonly)

Indicate that term may be used as a prefix



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

def prefix=(value)
  @prefix = value
end

#protected=(value) ⇒ Boolean (writeonly)

Term is protected.

Returns:

  • (Boolean) 


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

def protected=(value)
  @protected = value
end

#reverse_property ⇒ Boolean

Returns Reverse Property.

Returns:

  • (Boolean) —

    Reverse Property



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

def reverse_property
  @reverse_property
end

#simple ⇒ Boolean

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

Returns:

  • (Boolean) 


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

def simple
  @simple
end

#term ⇒ String

Returns term name.

Returns:

  • (String) —

    term name



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

def term
  @term
end

#type_mapping ⇒ String

Returns Type mapping.

Returns:

  • (String) —

    Type mapping



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

def type_mapping
  @type_mapping
end

Instance Method Details

#==(other) ⇒ Boolean

Check if term definitions are identical, modulo @protected

Returns:

  • (Boolean) 


2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
 
# File 'lib/json/ld/context.rb', line 2191

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) 


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

def as_set?; @as_set || false; end

#inspect ⇒ Object 



2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
 
# File 'lib/json/ld/context.rb', line 2208

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



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

def prefix?; @prefix; end

#protected? ⇒ Boolean

Term is protected.

Returns:

  • (Boolean) 


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

def protected?; !!@protected; end

#simple? ⇒ Boolean

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

Returns:

  • (Boolean) —

    simple



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

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


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
2161
2162
2163
2164
 
# File 'lib/json/ld/context.rb', line 2128

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) 


2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
 
# File 'lib/json/ld/context.rb', line 2170

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