Class: FrameNet::Frame

Inherits:
Object
  • Object
show all
Extended by:
Loggability
Defined in:
lib/frame_net/frame.rb

Overview

A Frame in FrameNet.

References:

Defined Under Namespace

Classes: Element, LexicalUnit, Relation

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize {|_self| ... } ⇒ Frame

Create a new Frame with the specified id, name, and modification_date.

Yields:

  • (_self)

Yield Parameters:



79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/frame_net/frame.rb', line 79

def initialize
	@id                   = nil
	@name                 = nil
	@creation_time        = Time.now
	@definition           = nil
	@elements             = []
	@relations            = []
	@lexical_units        = []
	@core_element_set_ids = []

	yield( self ) if block_given?
end

Instance Attribute Details

#core_element_set_ids ⇒ Object

The sets of FE IDs that make up the Frame’ FEcoreSets.



129
130
131
 
# File 'lib/frame_net/frame.rb', line 129

def core_element_set_ids
  @core_element_set_ids
end

#creation_time ⇒ Object Also known as: cDate, cDate=

The timestamp of when the node was created



107
108
109
 
# File 'lib/frame_net/frame.rb', line 107

def creation_time
  @creation_time
end

#definition ⇒ Object

The definition of the Frame.



113
114
115
 
# File 'lib/frame_net/frame.rb', line 113

def definition
  @definition
end

#elements ⇒ Object

The frame elements associated with the Frame, as an Array of FrameNet::Frame::Elements.



117
118
119
 
# File 'lib/frame_net/frame.rb', line 117

def elements
  @elements
end

#id ⇒ Object

The Frame’s ID



99
100
101
 
# File 'lib/frame_net/frame.rb', line 99

def id
  @id
end

#lexical_units ⇒ Object

The “lexical units” associated with the frame, as an Array of FrameNet::LexUnits.



125
126
127
 
# File 'lib/frame_net/frame.rb', line 125

def lexical_units
  @lexical_units
end

#name ⇒ Object

The Frame’s name as a Symbol



103
104
105
 
# File 'lib/frame_net/frame.rb', line 103

def name
  @name
end

#relations ⇒ Object

The frame relations associated with the Frame, as an Array of FrameNet::Frame::Relations.



121
122
123
 
# File 'lib/frame_net/frame.rb', line 121

def relations
  @relations
end

Class Method Details

.document_for(name) ⇒ Object

Return a LibXML::XML::Document for the data for the frame named name.



40
41
42
43
 
# File 'lib/frame_net/frame.rb', line 40

def self::document_for( name )
	path = "frame/%s.xml" % [ name.to_s.capitalize ]
	return FrameNet.load_document( path )
end

.load(name_or_id) ⇒ Object Also known as: []

Load the frame by name_or_id.



26
27
28
29
30
31
32
33
34
35
 
# File 'lib/frame_net/frame.rb', line 26

def self::load( name_or_id )
	case name_or_id
	when Numeric
		return FrameNet::Frame.load_by_id( name_or_id )
	when Symbol, String
		return FrameNet::Frame.load_by_name( name_or_id )
	else
		raise ArgumentError, "don't know how to load a frame from a %p" % [ name_or_id.class ]
	end
end

.load_by_id(id) ⇒ Object

Look up a Frame by its Integer id.



70
71
72
73
74
75
 
# File 'lib/frame_net/frame.rb', line 70

def self::load_by_id( id )
	self.log.debug "Loading frame for ID=%p" % [ id ]
	xpath = %{//fn:frame[@ID=%d]} % [ id ]
	node = FrameNet.frame_index.find_first( xpath ) or return nil
	return self.load_by_name( node['name'] )
end

.load_by_name(name) ⇒ Object

Load a Frame from the frame XML for the given name.



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/frame_net/frame.rb', line 47

def self::load_by_name( name )
	self.log.debug "Loading frame named %p" % [ name ]

	doc = self.document_for( name ) or
		raise ArgumentError, "No such frame %p!" % [ name ]

	return new do |frame|
		frame.id = Integer( doc.root['ID'] )
		frame.name = doc.root['name'].to_sym
		frame.creation_time = FrameNet.parse_time( doc.root['cDate'] )
		frame.definition = FrameNet::Definition.from_frame_data( doc )
		frame.elements = FrameNet::Frame::Element.from_frame_data( doc )
		frame.relations = FrameNet::Frame::Relation.from_frame_data( doc )
		frame.lexical_units = FrameNet::Frame::LexicalUnit.from_frame_data( doc )

		frame.core_element_set_ids = doc.find( '//fn:frame/fn:FEcoreSet' ).map do |set_el|
			set_el.find( './fn:memberFE' ).map {|el| el['ID'].to_i }
		end
	end
end

Instance Method Details

#==(other_frame) ⇒ Object Also known as: eql?

Object equality – returns true if the receiver repressents the same FrameNet frame as other_frame.



134
135
136
 
# File 'lib/frame_net/frame.rb', line 134

def ==( other_frame )
	return other_frame.is_a?( self.class ) && self.id == other_frame.id
end

#core_element_sets ⇒ Object

Return the Frame’s core element sets (FEcoreSets) as an Array of FrameNet::Frame::Elements.



174
175
176
177
178
179
 
# File 'lib/frame_net/frame.rb', line 174

def core_element_sets
	elements = self.elements_by_id
	return self.core_element_set_ids.map do |id_set|
		id_set.map {|id| elements[id] }
	end
end

#document ⇒ Object

Return the XML document that contains the data for the frame (if one exists). Returns nil if the document doesn’t exist.



285
286
287
 
# File 'lib/frame_net/frame.rb', line 285

def document
	return self.class.document_for( self.name )
end

#elements_by_core_type ⇒ Object

Return a Hash of this Frame’s FEs grouped by core type.



167
168
169
 
# File 'lib/frame_net/frame.rb', line 167

def elements_by_core_type
	return self.elements.group_by( &:core_type )
end

#elements_by_id ⇒ Object

Return the Hash of this Frame’s FEs keyed by numeric ID.



159
160
161
162
163
 
# File 'lib/frame_net/frame.rb', line 159

def elements_by_id
	return self.elements.each_with_object( {} ) do |el, hash|
		hash[ el.id ] = el
	end
end

#has_subframes ⇒ Object Also known as: has_subframe

Return Frames which are a subframe of the receiver.



239
240
241
 
# File 'lib/frame_net/frame.rb', line 239

def has_subframes
	return self.relations_hash[ "Has Subframe(s)" ].frames
end

#inherits_from ⇒ Object

Return Frames the receiver inherits from.



196
197
198
 
# File 'lib/frame_net/frame.rb', line 196

def inherits_from
	return self.relations_hash[ "Inherits from" ].frames
end

#inspect ⇒ Object

Return the Frame as a human-readable string suitable for debugging.



141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/frame_net/frame.rb', line 141

def inspect
	return %{#<%p:%#016x "%s" [%d] %d elements, %d relations, %d lexical units>} % [
		self.class,
		self.object_id * 2,
		self.name || "(Unnamed)",
		self.id || 0,
		self.elements.length,
		self.relations.count {|rel| !rel.empty? },
		self.lexical_units.length,
	]
end

#is_causative_of ⇒ Object

Return Frames in which the receiving frame is a causative subframe.



266
267
268
 
# File 'lib/frame_net/frame.rb', line 266

def is_causative_of
	return self.relations_hash[ "Is Causative of" ].frames
end

#is_inchoative_of ⇒ Object

Return Frames in which the receiving frame is an inchoative subframe.



260
261
262
 
# File 'lib/frame_net/frame.rb', line 260

def is_inchoative_of
	return self.relations_hash[ "Is Inchoative of" ].frames
end

#is_inherited_by ⇒ Object

Return Frames the receiver is inherited by.



202
203
204
 
# File 'lib/frame_net/frame.rb', line 202

def is_inherited_by
	return self.relations_hash[ "Is Inherited by" ].frames
end

#is_perspectivized_in ⇒ Object

Return Frames which represent different states of affairs of the receiving Frame.



215
216
217
 
# File 'lib/frame_net/frame.rb', line 215

def is_perspectivized_in
	return self.relations_hash[ "Is Perspectivized in" ].frames
end

#is_preceded_by ⇒ Object

Return Frames the receiver comes after in a series of subframes of another Frame.



254
255
256
 
# File 'lib/frame_net/frame.rb', line 254

def is_preceded_by
	return self.relations_hash[ "Is Preceded by" ].frames
end

#is_used_by ⇒ Object

Return Frames the receiver is used by.



227
228
229
 
# File 'lib/frame_net/frame.rb', line 227

def is_used_by
	return self.relations_hash[ "Is Used by" ].frames
end

#perspective_on ⇒ Object

Return Frames in which the receiver is one of several perspectives.



208
209
210
 
# File 'lib/frame_net/frame.rb', line 208

def perspective_on
	return self.relations_hash[ "Perspective on" ].frames
end

#precedes ⇒ Object

Return Frames the receiver comes before in a series of subframes of another Frame.



247
248
249
 
# File 'lib/frame_net/frame.rb', line 247

def precedes
	return self.relations_hash[ "Precedes" ].frames
end

#relations_hash ⇒ Object

Return the FrameNet::Frame::Relations this Frame has as a Hash keyed by the Relation’s type as a String.



188
189
190
191
192
 
# File 'lib/frame_net/frame.rb', line 188

def relations_hash
	return self.relations.each_with_object( {} ) do |rel, hash|
		hash[ rel.type ] = rel
	end
end

#see_also ⇒ Object

Return the other members of a group of Frames which should be compared to the receiving Frame.



273
274
275
 
# File 'lib/frame_net/frame.rb', line 273

def see_also
	return self.relations_hash[ "See also" ].frames
end

#subframe_of ⇒ Object

Return Frames the receiver is a subframe of.



233
234
235
 
# File 'lib/frame_net/frame.rb', line 233

def subframe_of
	return self.relations_hash[ "Subframe of" ].frames
end

#uses ⇒ Object

Return Frames the receiver uses in some capacity.



221
222
223
 
# File 'lib/frame_net/frame.rb', line 221

def uses
	return self.relations_hash[ "Uses" ].frames
end