Class: Lbp::Expression

Inherits:
Resource show all
Defined in:
lib/lbp/expression.rb

Instance Attribute Summary

Attributes inherited from Resource

#resource_shortId, #resource_url, #results

Instance Method Summary collapse

Methods inherited from Resource

#convert, #initialize, #structureType, #structureType_shortId, #title, #type, #type_shortId

Constructor Details

This class inherits a constructor from Lbp::Resource

Instance Method Details

#abbreviatedBy ⇒ Object 



137
138
139
 
# File 'lib/lbp/expression.rb', line 137

def abbreviatedBy
	abbreviatedBy = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/abbreviatedBy"))
end

#abbreviates ⇒ Object

connection properties

TODO: notice how all these return RDF::Solutions (or some RDF

object)

rather already performing the conversion to strings as is done in all the above methods this should be standardized



134
135
136
 
# File 'lib/lbp/expression.rb', line 134

def abbreviates
	abbreviates = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/abbreviates"))
end

#canonicalManifestation ⇒ Object 



25
26
27
28
29
 
# File 'lib/lbp/expression.rb', line 25

def canonicalManifestation
	url = self.canonicalManifestationUrl
	manifestationObj = Manifestation.new(url)
	return manifestationObj
end

#canonicalManifestation? ⇒ Boolean

Returns:

  • (Boolean) 


30
31
32
33
34
35
36
 
# File 'lib/lbp/expression.rb', line 30

def canonicalManifestation?
	if self.canonicalManifestationUrl == nil
		return false
	else
		return true
	end
end

#canonicalManifestationUrl ⇒ Object 



21
22
23
24
 
# File 'lib/lbp/expression.rb', line 21

def canonicalManifestationUrl
	manifestation = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/hasCanonicalManifestation")).first[:o].to_s
	return manifestation
end

#canonicalTranscription ⇒ Object 



44
45
46
47
48
 
# File 'lib/lbp/expression.rb', line 44

def canonicalTranscription
	url = self.canonicalTranscriptionUrl
	transcriptionObj = Transcription.new(url)
	return transcriptionObj
end

#canonicalTranscription? ⇒ Boolean

Returns:

  • (Boolean) 


49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/lbp/expression.rb', line 49

def canonicalTranscription?
	if self.canonicalManifestation? == false
		return false
	else
		if self.canonicalTranscriptionUrl == nil
			return false
		else
			return true
		end
	end
end

#canonicalTranscriptionUrl ⇒ Object

cannonical transcriptions refers to the canonical trancription of the canonical manifestation



39
40
41
42
43
 
# File 'lib/lbp/expression.rb', line 39

def canonicalTranscriptionUrl
	manifestationObj = self.canonicalManifestation
	url = manifestationObj.canonicalTranscriptionUrl
	return url
end

#copiedBy ⇒ Object 



149
150
151
 
# File 'lib/lbp/expression.rb', line 149

def copiedBy
	copies = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/copiedBy"))
end

#copies ⇒ Object 



146
147
148
 
# File 'lib/lbp/expression.rb', line 146

def copies
	copies = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/copies"))
end

#item_level_expression ⇒ Object 



117
118
119
 
# File 'lib/lbp/expression.rb', line 117

def item_level_expression
	expression = Expression.new(self.item_level_expression_url)
end

#item_level_expression_shortId ⇒ Object 



114
115
116
 
# File 'lib/lbp/expression.rb', line 114

def item_level_expression_shortId
	self.item_level_expression_url.split("/").last
end

#item_level_expression_url ⇒ Object 



110
111
112
113
 
# File 'lib/lbp/expression.rb', line 110

def item_level_expression_url
	#TODO make sure this can handle different structure types
	status = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/isPartOfStructureItem")).first[:o].to_s
end

#level ⇒ Object 



120
121
122
123
124
125
126
127
128
 
# File 'lib/lbp/expression.rb', line 120

def level
	result = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/level")).first[:o]
	unless self.results.count == 0 
		level = result.to_s.to_i
	else
		level = nil
	end
	return level
end

#manifestationUrls ⇒ Object

inherits initialization from Resource



16
17
18
19
20
 
# File 'lib/lbp/expression.rb', line 16

def manifestationUrls
	results = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/hasManifestation"))
	manifestations = results.map {|m| m[:o].to_s}
	return manifestations
end

#mentions ⇒ Object 



152
153
154
 
# File 'lib/lbp/expression.rb', line 152

def mentions
	mentions = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/mentions"))
end

#next ⇒ Object 



70
71
72
73
74
75
76
77
 
# File 'lib/lbp/expression.rb', line 70

def next
	unless self.results.dup.filter(:p => RDF::URI("http://scta.info/property/next")).count == 0
		next_expression = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/next")).first[:o].to_s
	else
		next_expression = nil
	end
	return next_expression
end

#order_number ⇒ Object 



86
87
88
89
90
91
92
93
94
 
# File 'lib/lbp/expression.rb', line 86

def order_number
	## TODO: consider changing property so that there is more symmetry here
	if self.structureType_shortId == "structureBlock"
		ordernumber = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/paragraphNumber")).first[:o].to_s.to_i
	else
		ordernumber = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/totalOrderNumber")).first[:o].to_s.to_i
	end
	return ordernumber
end

#previous ⇒ Object 



78
79
80
81
82
83
84
85
 
# File 'lib/lbp/expression.rb', line 78

def previous
	unless self.results.dup.filter(:p => RDF::URI("http://scta.info/property/previous")).count == 0
		previous_expression = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/previous")).first[:o].to_s
	else
		previous_expression = nil
	end
	return previous_expression
end

#quotedBy ⇒ Object 



158
159
160
 
# File 'lib/lbp/expression.rb', line 158

def quotedBy
	quotedBy = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/quotedBy"))
end

#quotes ⇒ Object 



155
156
157
 
# File 'lib/lbp/expression.rb', line 155

def quotes
	quotes = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/quotes"))
end

#referencedBy ⇒ Object 



143
144
145
 
# File 'lib/lbp/expression.rb', line 143

def referencedBy
	references = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/referencedBy"))
end

#references ⇒ Object 



140
141
142
 
# File 'lib/lbp/expression.rb', line 140

def references
	references = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/references"))
end

#status ⇒ Object 



95
96
97
 
# File 'lib/lbp/expression.rb', line 95

def status
	status = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/status")).first[:o].to_s
end

#top_level_expression ⇒ Object 



106
107
108
 
# File 'lib/lbp/expression.rb', line 106

def top_level_expression
	expression = Expression.new(self.top_level_expression_url)
end

#top_level_expression_shortId ⇒ Object 



103
104
105
 
# File 'lib/lbp/expression.rb', line 103

def top_level_expression_shortId
	self.top_level_expression_url.split("/").last
end

#top_level_expression_url ⇒ Object 



99
100
101
102
 
# File 'lib/lbp/expression.rb', line 99

def top_level_expression_url
	#TODO make sure this can handle different structure types
	status = self.results.dup.filter(:p => RDF::URI("http://scta.info/property/isPartOfTopLevelExpression")).first[:o].to_s
end

#transcription(manifestationUrl) ⇒ Object 



65
66
67
68
69
 
# File 'lib/lbp/expression.rb', line 65

def transcription(manifestationUrl)
	manifestationObj = Manifestation.new(manifestationUrl)
	transcriptionObj = manifestationObj.canonicalTranscription 
	return transcriptionObj
end

#transcriptionUrl(manifestationUrl) ⇒ Object 



60
61
62
63
64
 
# File 'lib/lbp/expression.rb', line 60

def transcriptionUrl(manifestationUrl)
	manifestationObj = Manifestation.new(manifestationUrl)
	transcriptionObj = manifestationObj.canonicalTranscriptionUrl 
	return transcriptionObj
end