# -*- ruby -*-

require 'wordnet' unless defined?( WordNet )

# This is a module containing constants used in the WordNet interface for
# Ruby. They are contained in a module to facilitate their easy inclusion in
# other namespaces. All constants in this module are also contained in the
# WordNet namespace itself.
module WordNet::Constants

	# The default database options
	DEFAULT_DB_OPTIONS = {}

	# Synset syntactic-category names -> indicators
	SYNTACTIC_CATEGORIES = {
		noun: "n",
		verb: "v",
		adjective: "a",
		adverb: "r",
		other: "s",
	}
	# Syntactic-category indicators -> names
	SYNTACTIC_SYMBOLS = SYNTACTIC_CATEGORIES.invert

	# Map the categories into their own constants (eg., Noun)
	SYNTACTIC_CATEGORIES.each do |sym,val|
		cname = sym.to_s.capitalize
		const_set( cname, val )
	end

	# Information about pointer types is contained in the wninput(5WN)
	# manpage.

	# Synset pointer typenames -> indicators
	POINTER_TYPES = {
		antonym: '!',
		hypernym: '@',
		entailment: '*',
		hyponym: '~',
		meronym: '%',
		holonym: '#',
		cause: '>',
		verb_group: '$',
		similar_to: '&',
		participle: '<',
		pertainym: '\\',
		attribute: '=',
		derived_from: '\\',
		see_also: '^',
		derivation: '+',
		domain: ';',
		member: '-',
	}

	# Synset pointer indicator -> typename
	POINTER_SYMBOLS = POINTER_TYPES.invert

	# Map the pointer types into their own symbols (eg., verb_group: VerbGroup)
	POINTER_TYPES.each do |sym,val|
		cname = sym.to_s.gsub( /(?:^|_)(.)/ ) { $1.upcase }
		const_set( cname, val )
	end

	# Hypernym synset pointer types
	HYPERNYM_TYPES = {
		nil             => '@', # Install non-subtype methods, too
		instance: '@i',
	}

	# Hypernym indicator -> type map
	HYPERNYM_SYMBOLS = HYPERNYM_TYPES.invert

	# Hyponym synset pointer types
	HYPONYM_TYPES = {
		nil             => '~', # Install non-subtype methods, too
		instance: '~i',
	}

	# Hyponym indicator -> type map
	HYPONYM_SYMBOLS = HYPONYM_TYPES.invert

	# Meronym synset pointer types
	MERONYM_TYPES = {
		member: '%m',
		stuff: '%s',
		portion: '%o',
		component: '%p',
		feature: '%f',
		phase: '%a',
		place: '%l',
	}

	# Meronym indicator -> type map
	MERONYM_SYMBOLS = MERONYM_TYPES.invert

	# Map the meronym types into their own constants (eg., MemberMeronym)
	MERONYM_TYPES.each do |sym,val|
		cname = sym.to_s.capitalize + "Meronym"
		const_set( cname, val )
	end

	# Holonym synset pointer types
	HOLONYM_TYPES = {
		member: '#m',
		stuff: '#s',
		portion: '#o',
		component: '#p',
		feature: '#f',
		phase: '#a',
		place: '#l',
	}

	# Holonym indicator -> type map
	HOLONYM_SYMBOLS = HOLONYM_TYPES.invert

	# Map the holonym types into their own constants (eg., MemberHolonym)
	HOLONYM_TYPES.each do |sym,val|
		cname = sym.to_s.capitalize + "Holonym"
		const_set( cname, val )
	end

	# Domain synset pointer types
	DOMAIN_TYPES = {
		category: ';c',
		region: ';r',
		usage: ';u',
	}

	# Domain indicator -> type map
	DomainSymbols = DOMAIN_TYPES.invert

	# Map the domain types into their own constants (eg., CategoryDomain)
	DOMAIN_TYPES.each do |sym,val|
		cname = sym.to_s.capitalize + "Domain"
		const_set( cname, val )
	end

	# Member synset pointer types
	MEMBER_TYPES = {
		category: '-c',
		region: '-r',
		usage: '-u',
	}

	# Member indicator -> type map
	MEMBER_SYMBOLS = MEMBER_TYPES.invert

	# Map the member types into their own constants (eg., CategoryMember)
	MEMBER_TYPES.each do |sym,val|
		cname = sym.to_s.capitalize + "Member"
		const_set( cname, val )
	end

	# Map of primary types to maps of their subtypes
	POINTER_SUBTYPES = {
		hyponym: HYPONYM_TYPES,
		hypernym: HYPERNYM_TYPES,
		meronym: MERONYM_TYPES,
		holonym: HOLONYM_TYPES,
		member: MEMBER_TYPES,
		domain: DOMAIN_TYPES,
	}


	# Record-part delimiter
	DELIM = '||'
	DELIM_RE = Regexp.new( Regexp::quote(DELIM) )

	# Record-subpart delimiter
	SUB_DELIM = '|'
	SUB_DELIM_RE = Regexp.new( Regexp::quote(SUB_DELIM) )

	# Lexicographer file index -- from lexnames(5WN)
	LEXFILES = [
		"adj.all",
		"adj.pert",
		"adv.all",
		"noun.Tops",
		"noun.act",
		"noun.animal",
		"noun.artifact",
		"noun.attribute",
		"noun.body",
		"noun.cognition",
		"noun.communication",
		"noun.event",
		"noun.feeling",
		"noun.food",
		"noun.group",
		"noun.location",
		"noun.motive",
		"noun.object",
		"noun.person",
		"noun.phenomenon",
		"noun.plant",
		"noun.possession",
		"noun.process",
		"noun.quantity",
		"noun.relation",
		"noun.shape",
		"noun.state",
		"noun.substance",
		"noun.time",
		"verb.body",
		"verb.change",
		"verb.cognition",
		"verb.communication",
		"verb.competition",
		"verb.consumption",
		"verb.contact",
		"verb.creation",
		"verb.emotion",
		"verb.motion",
		"verb.perception",
		"verb.possession",
		"verb.social",
		"verb.stative",
		"verb.weather",
		"adj.ppl"
	]

	# Verb sentences (?) -- used in building verb frames.
	VERB_SENTS = [
		"",
		"Something ----s",
		"Somebody ----s",
		"It is ----ing",
		"Something is ----ing PP",
		"Something ----s something Adjective/Noun",
		"Something ----s Adjective/Noun",
		"Somebody ----s Adjective",
		"Somebody ----s something",
		"Somebody ----s somebody",
		"Something ----s somebody",
		"Something ----s something",
		"Something ----s to somebody",
		"Somebody ----s on something",
		"Somebody ----s somebody something",
		"Somebody ----s something to somebody",
		"Somebody ----s something from somebody",
		"Somebody ----s somebody with something",
		"Somebody ----s somebody of something",
		"Somebody ----s something on somebody",
		"Somebody ----s somebody PP",
		"Somebody ----s something PP",
		"Somebody ----s PP",
		"Somebody's (body part) ----s",
		"Somebody ----s somebody to INFINITIVE",
		"Somebody ----s somebody INFINITIVE",
		"Somebody ----s that CLAUSE",
		"Somebody ----s to somebody",
		"Somebody ----s to INFINITIVE",
		"Somebody ----s whether INFINITIVE",
		"Somebody ----s somebody into V-ing something",
		"Somebody ----s something with something",
		"Somebody ----s INFINITIVE",
		"Somebody ----s VERB-ing",
		"It ----s that CLAUSE",
		"Something ----s INFINITIVE"
	]


end # module Wordnet::Constants

