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

.camel_case(string) ⇒ Object
.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.
.try_load_const(item_type) ⇒ Object

It convert name to const name and try to find it in autload directory.
.unregister(vocabulary) ⇒ Object

Un-register a vocabulary.

Class Attribute Details

.vocabularies ⇒ `Object` (readonly)

Return the registered vocabularies



13
14
15

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

def vocabularies
  @vocabularies
end

Class Method Details

.camel_case(string) ⇒ `Object`

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

def self.camel_case(string)
  return string if string !~ /_/ && string =~ /[A-Z]+.*/
  string.split('_').map {|e| e.capitalize }.join
end

.find(itemtype) ⇒ `Object`

Find the last vocabulary registered that matches the itemtype

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

def self.find(itemtype)
  if const = try_load_const(itemtype)
    return const
  else
    @vocabularies.sort_by {|v| v.itemtype ? v.itemtype.source.size : 0 }.reverse.each do |vocabulary|
      if ((itemtype || "") =~ vocabulary.itemtype)
        return vocabulary
      end
    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



138
139
140

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

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



131
132
133

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

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 106

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



99
100
101

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

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

.inherited(subclass) ⇒ `Object`



82
83
84

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

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 123

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

Returns:

(Boolean)

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

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 89

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`



20
21
22

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

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

.try_load_const(item_type) ⇒ `Object`

It convert name to const name and try to find it in autload directory

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

def self.try_load_const(item_type)
  # http://schema.org/Winery => winery
  # http://schema.org/AutomotiveBusiness => automotivebusiness
  # http://data-vocabulary.org/Offer-aggregate/ => offeraggregate

  if item_type =~ /https?:\/\//
    uri = URI.parse(item_type)
    if uri.host != 'schema.org' && uri.host != 'data-vocabulary.org'
      return nil
    end
    item_type = uri.path.gsub('/', '').gsub('-', '')
  end
  constName = camel_case(item_type)

  if Mida::SchemaOrg.const_defined?(constName, false)
    return Mida::SchemaOrg.const_get(constName, false)
  end

  if Mida::DataVocabulary.const_defined?(constName, false)
    return Mida::DataVocabulary.const_get(constName, false)
  end

  load_path = File.dirname(__FILE__) + "/vocabularies/schemaorg/#{constName.downcase}.rb"
  if File.exist?(load_path)
    return Mida::SchemaOrg.const_get(constName, false) # hit autoloader
  end

  load_path = File.dirname(__FILE__) + "/vocabularies/data_vocabulary/#{constName.downcase}.rb"
  if File.exist?(load_path)
    return Mida::DataVocabulary.const_get(constName, false) # hit autoloader
  end
end

.unregister(vocabulary) ⇒ `Object`

Un-register a vocabulary



25
26
27

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

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

.camel_case(string) ⇒ Object

.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

.try_load_const(item_type) ⇒ Object

.unregister(vocabulary) ⇒ Object