Class: Mida::Vocabulary

Inherits:

Object

Object
Mida::Vocabulary

show all

Defined in:: lib/mida_vocabulary/vocabulary.rb

Overview

Class used to describe a vocabulary

To specify a vocabulary use the following methods: itemtype, has_one, has_many

Direct Known Subclasses

Class Attribute Summary collapse

.vocabularies ⇒ Object readonly

Return the registered vocabularies.

Class Method Summary collapse

.find(itemtype) ⇒ Object

Find the last vocabulary registered that matches the itemtype.
.has_many(*property_names, &block) ⇒ Object

Defines the properties as containing many values If want to say any property name, then use :any as a name Within a block you can use the methods of the class PropertyDesc.
.has_one(*property_names, &block) ⇒ Object

Defines the properties as only containing one value If want to say any property name, then use :any as a name Within a block you can use the methods of the class PropertyDesc.
.include_vocabulary(*vocabularies) ⇒ Object

Specify which vocabularies will have their properties included.
.included_vocabularies ⇒ Object

Return the included vocabularies.
.inherited(subclass) ⇒ Object
.itemtype(regexp = nil) ⇒ Object

Sets the regular expression to match against the itemtype or returns the current regular expression.
.kind_of?(vocabulary) ⇒ Boolean

As per the standard kind_of?, but also checks to see if vocabulary has been included by self.
.properties ⇒ Object

Return the properties specification This won’t work properly until all the included_vocabularies have finished being defined in case of circular dependancies.
.register(vocabulary) ⇒ Object

Register a vocabulary that can be used when parsing, later vocabularies are given precedence over earlier ones.
.unregister(vocabulary) ⇒ Object

Un-register a vocabulary.

Class Attribute Details

.vocabularies ⇒ `Object` (readonly)

Return the registered vocabularies



12
13
14

# File 'lib/mida_vocabulary/vocabulary.rb', line 12

def vocabularies
  @vocabularies
end

Class Method Details

.find(itemtype) ⇒ `Object`

Find the last vocabulary registered that matches the itemtype

# File 'lib/mida_vocabulary/vocabulary.rb', line 29

def self.find(itemtype)
  @vocabularies.sort_by {|v| v.itemtype ? v.itemtype.source.size : 0 }.reverse.each do |vocabulary|
    if ((itemtype || "") =~ vocabulary.itemtype)
      return vocabulary
    end
  end
  nil
end

.has_many(*property_names, &block) ⇒ `Object`

Defines the properties as containing many values If want to say any property name, then use :any as a name Within a block you can use the methods of the class PropertyDesc



94
95
96

# File 'lib/mida_vocabulary/vocabulary.rb', line 94

def self.has_many(*property_names, &block)
  has(:many, *property_names, &block)
end

.has_one(*property_names, &block) ⇒ `Object`

Defines the properties as only containing one value If want to say any property name, then use :any as a name Within a block you can use the methods of the class PropertyDesc



87
88
89

# File 'lib/mida_vocabulary/vocabulary.rb', line 87

def self.has_one(*property_names, &block)
  has(:one, *property_names, &block)
end

.include_vocabulary(*vocabularies) ⇒ `Object`

Specify which vocabularies will have their properties included. This is the correct way to inherit properties from another vocabulary, rather than subclassing.

# File 'lib/mida_vocabulary/vocabulary.rb', line 62

def self.include_vocabulary(*vocabularies)
  vocabularies.each do |vocabulary|
    included_vocabularies.merge(vocabulary.included_vocabularies)
    included_vocabularies << vocabulary
  end
end

.included_vocabularies ⇒ `Object`

Return the included vocabularies



55
56
57

# File 'lib/mida_vocabulary/vocabulary.rb', line 55

def self.included_vocabularies
  @included_vocabularies ||= Set.new
end

.inherited(subclass) ⇒ `Object`



38
39
40

# File 'lib/mida_vocabulary/vocabulary.rb', line 38

def self.inherited(subclass)
  register(subclass)
end

.itemtype(regexp = nil) ⇒ `Object`

Sets the regular expression to match against the itemtype or returns the current regular expression

# File 'lib/mida_vocabulary/vocabulary.rb', line 79

def self.itemtype(regexp=nil)
  return @itemtype unless regexp
  @itemtype = regexp
end

.kind_of?(vocabulary) ⇒ `Boolean`

As per the standard kind_of?, but also checks to see if vocabulary has been included by self

# File 'lib/mida_vocabulary/vocabulary.rb', line 71

def self.kind_of?(vocabulary)
  return true if self == vocabulary
  return true if self.ancestors.include?(vocabulary)
  included_vocabularies.include?(vocabulary)
end

.properties ⇒ `Object`

Return the properties specification This won’t work properly until all the included_vocabularies have finished being defined in case of circular dependancies

# File 'lib/mida_vocabulary/vocabulary.rb', line 45

def self.properties
  return @properties if @properties
  @properties = @this_properties || {}
  included_vocabularies.each do |vocabulary|
    @properties.merge!(vocabulary.properties)
  end
  @properties
end

.register(vocabulary) ⇒ `Object`



19
20
21

# File 'lib/mida_vocabulary/vocabulary.rb', line 19

def self.register(vocabulary)
  @vocabularies << vocabulary
end

.unregister(vocabulary) ⇒ `Object`

Un-register a vocabulary



24
25
26

# File 'lib/mida_vocabulary/vocabulary.rb', line 24

def self.unregister(vocabulary)
  @vocabularies.delete(vocabulary)
end

Class: Mida::Vocabulary

Overview

Direct Known Subclasses

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.vocabularies ⇒ Object (readonly)

Class Method Details

.find(itemtype) ⇒ Object

.has_many(*property_names, &block) ⇒ Object

.has_one(*property_names, &block) ⇒ Object

.include_vocabulary(*vocabularies) ⇒ Object

.included_vocabularies ⇒ Object

.inherited(subclass) ⇒ Object

.itemtype(regexp = nil) ⇒ Object

.kind_of?(vocabulary) ⇒ Boolean

.properties ⇒ Object

.register(vocabulary) ⇒ Object

.unregister(vocabulary) ⇒ Object