Module: ActiveFedora::SemanticNode

Extended by:
ActiveSupport::Concern
Included in:
Base
Defined in:
lib/active_fedora/semantic_node.rb

Defined Under Namespace

Modules: ClassMethods

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#load_from_solr ⇒ Object

Returns the value of attribute load_from_solr.



10
11
12
 
# File 'lib/active_fedora/semantic_node.rb', line 10

def load_from_solr
  @load_from_solr
end

#relationships_loaded ⇒ Object

Returns the value of attribute relationships_loaded.



10
11
12
 
# File 'lib/active_fedora/semantic_node.rb', line 10

def relationships_loaded
  @relationships_loaded
end

#subject ⇒ Object

Returns the value of attribute subject.



10
11
12
 
# File 'lib/active_fedora/semantic_node.rb', line 10

def subject
  @subject
end

Instance Method Details

#add_relationship(predicate, target, literal = false) ⇒ Object

Add a relationship to the Object.

Parameters:

  • predicate
  • object —

    Either a string URI or an object that is a kind of ActiveFedora::Base



31
32
33
34
 
# File 'lib/active_fedora/semantic_node.rb', line 31

def add_relationship(predicate, target, literal=false)
  object_relations.add(predicate, target, literal)
  rels_ext.dirty = true
end

#assert_kind_of(n, o, t) ⇒ Object 



12
13
14
 
# File 'lib/active_fedora/semantic_node.rb', line 12

def assert_kind_of(n, o,t)
  raise "Assertion failure: #{n}: #{o} is not of type #{t}" unless o.kind_of?(t)
end

#build_statement(uri, predicate, target, literal = false) ⇒ Object

Create an RDF statement

Parameters:

  • uri —

    a string represending the subject

  • predicate —

    a predicate symbol

  • target —

    an object to store



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/active_fedora/semantic_node.rb', line 77

def build_statement(uri, predicate, target, literal=false)
  ActiveSupport::Deprecation.warn("ActiveFedora::Base#build_statement has been deprecated.")
  raise "Not allowed anymore" if uri == :self
  target = target.internal_uri if target.respond_to? :internal_uri
  subject =  RDF::URI.new(uri)  #TODO cache
  unless literal or target.is_a? RDF::Resource
    begin
      target_uri = (target.is_a? URI) ? target : URI.parse(target)
      if target_uri.scheme.nil?
        raise ArgumentError, "Invalid target \"#{target}\". Must have namespace."
      end
      if target_uri.to_s =~ /\A[\w\-]+:[\w\-]+\Z/
        raise ArgumentError, "Invalid target \"#{target}\". Target should be a complete URI, and not a pid."
      end
    rescue URI::InvalidURIError
      raise ArgumentError, "Invalid target \"#{target}\". Target must be specified as a literal, or be a valid URI."
    end
  end
  if literal
    object = RDF::Literal.new(target)
  elsif target.is_a? RDF::Resource
    object = target
  else
    object = RDF::URI.new(target)
  end
  RDF::Statement.new(subject, find_graph_predicate(predicate), object)

end

#clear_relationship(predicate) ⇒ Object

Clears all relationships with the specified predicate

Parameters:

  • predicate 


38
39
40
41
42
43
 
# File 'lib/active_fedora/semantic_node.rb', line 38

def clear_relationship(predicate)
  relationships(predicate).each do |target|
    object_relations.delete(predicate, target) 
  end
  rels_ext.dirty = true
end

#conforms_to?(model_class) ⇒ Boolean

Checks that this object is matches the model class passed in. It requires two steps to pass to return true

1. It has a hasModel relationship of the same model
2. kind_of? returns true for the model passed in

This method can most often be used to detect if an object from Fedora that was created with a different model was then used to populate this object.

Parameters:

  • the (Class) —

    model class name to check if an object conforms_to that model

Returns:

  • (Boolean) —

    true if this object conforms to the given model name



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/active_fedora/semantic_node.rb', line 53

def conforms_to?(model_class)
  if self.kind_of?(model_class)
    #check has model and class match
    mod = relationships.first(:predicate=>Predicates.find_graph_predicate(:has_model))
    if mod
      expected = self.class.to_class_uri
      if mod.object.to_s == expected
        return true
      else
        raise "has_model relationship check failed for model #{model_class} raising exception, expected: '#{expected}' actual: '#{mod.object.to_s}'"
      end
    else
      raise "has_model relationship does not exist for model #{model_class} check raising exception"
    end
  else
    raise "kind_of? check failed for model #{model_class}, actual #{self.class} raising exception"
  end
  return false
end

#ids_for_outbound(predicate) ⇒ Object 



162
163
164
165
166
167
 
# File 'lib/active_fedora/semantic_node.rb', line 162

def ids_for_outbound(predicate)
  (object_relations[predicate] || []).map do |o|
    o = o.to_s if o.kind_of? RDF::Literal
    o.kind_of?(String) ? o.gsub("info:fedora/", "") : o.pid
  end
end

#inbound_relationship_predicates ⇒ Hash

Return hash of inbound relationship names and predicate pairs

Returns:

  • (Hash) —

    A hash of inbound relationship names mapped to predicates used



204
205
206
 
# File 'lib/active_fedora/semantic_node.rb', line 204

def inbound_relationship_predicates
  relationship_predicates.has_key?(:inbound) ? relationship_predicates[:inbound] : {}
end

#inbound_relationships(response_format = :uri) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/active_fedora/semantic_node.rb', line 118

def inbound_relationships(response_format=:uri)
  rel_values = {}
  inbound_relationship_predicates.each_pair do |name,predicate|
    objects = self.send("#{name}",{:response_format=>response_format})
    items = []
    objects.each do |object|
      if (response_format == :uri)    
        #inbound relationships are always object properties
        items.push(object.internal_uri)
      else
        items.push(object)
      end
    end
    unless items.empty?
      rel_values.merge!({predicate=>items})
    end
  end
  return rel_values  
end

#load_relationships ⇒ Object 



155
156
157
158
159
160
 
# File 'lib/active_fedora/semantic_node.rb', line 155

def load_relationships
  self.relationships_loaded = true
  content = rels_ext.content
  return unless content.present?
  RelsExtDatastream.from_xml content, rels_ext
end

#object_relations ⇒ Object 



16
17
18
19
 
# File 'lib/active_fedora/semantic_node.rb', line 16

def object_relations
  load_relationships if !relationships_loaded
  @object_relations ||= RelationshipGraph.new
end

#outbound_relationship_predicates ⇒ Hash

Return hash of outbound relationship names and predicate pairs

Returns:

  • (Hash) —

    A hash of outbound relationship names mapped to predicates used



198
199
200
 
# File 'lib/active_fedora/semantic_node.rb', line 198

def outbound_relationship_predicates
  relationship_predicates.has_key?(:self) ? relationship_predicates[:self] : {}
end

#outbound_relationships ⇒ Object 



138
139
140
 
# File 'lib/active_fedora/semantic_node.rb', line 138

def outbound_relationships()
  relationships.statements
end

#relationship_predicates ⇒ Hash

Return hash of relationship names and predicate pairs (inbound and outbound). It retrieves this information via the relationships_desc hash in the class.

Returns:

  • (Hash) —

    A hash of relationship names (inbound and outbound) mapped to predicates used



184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/active_fedora/semantic_node.rb', line 184

def relationship_predicates
  return @relationship_predicates if @relationship_predicates
  @relationship_predicates = {}
  relationships_desc.each_pair do |subj, names|
    @relationship_predicates[subj] = {}
    names.each_pair do |name, args|
      @relationship_predicates[subj][name] = args[:predicate]
    end
  end
  @relationship_predicates
end

#relationships(*args) ⇒ Object

If no arguments are supplied, return the whole RDF::Graph. if a predicate is supplied as a parameter, then it returns the result of quering the graph with that predicate



144
145
146
147
148
149
150
151
152
153
 
# File 'lib/active_fedora/semantic_node.rb', line 144

def relationships(*args)
  load_relationships if !relationships_loaded

  if args.empty?
    raise "Must have internal_uri" unless internal_uri
    return object_relations.to_graph(internal_uri)
  end
  rels = object_relations[args.first] || []
  rels.map {|o| o.respond_to?(:internal_uri) ? o.internal_uri : o }   #TODO, could just return the object
end

#relationships_are_dirty ⇒ Object 



21
22
23
 
# File 'lib/active_fedora/semantic_node.rb', line 21

def relationships_are_dirty
  object_relations.dirty
end

#relationships_are_dirty=(val) ⇒ Object 



24
25
26
 
# File 'lib/active_fedora/semantic_node.rb', line 24

def relationships_are_dirty=(val)
  object_relations.dirty = val
end

#relationships_desc ⇒ Hash

Return hash that persists relationship metadata defined by has_relationship calls

Examples:

For the following relationship


has_relationship "audio_records", :has_part, :type=>AudioRecord

Results in the following returned by relationships_desc
{:self=>{"audio_records"=>{:type=>AudioRecord, :singular=>nil, :predicate=>:has_part, :inbound=>false}}}

Returns:

  • (Hash) —

    Hash of relationship subject (:self or :inbound) mapped to nested hashs of each relationship name mapped to another hash relationship options



177
178
179
 
# File 'lib/active_fedora/semantic_node.rb', line 177

def relationships_desc
  @relationships_desc ||= self.class.relationships_desc
end

#remove_relationship(predicate, obj, literal = false) ⇒ Object

Remove a Rels-Ext relationship from the Object.

Parameters:

  • predicate
  • object —

    Either a string URI or an object that responds to .pid



112
113
114
115
116
 
# File 'lib/active_fedora/semantic_node.rb', line 112

def remove_relationship(predicate, obj, literal=false)
  object_relations.delete(predicate, obj)
  self.relationships_are_dirty = true
  rels_ext.dirty = true
end