treat 1.2.0 → 2.0.0rc1

data/lib/treat/config/tags/aligned.rb

@@ -1,221 +0,0 @@
-{tag_sets: [
-  :claws_c5, :brown, :penn, :stutgart, :chinese, :paris7
-],
-phrase_tags: [
-  'Adjectival phrase', ['', '', 'ADJP', '', '', 'AP'],
-  'Adverbial phrase', ['', '', 'ADVP', '', '', 'AdP'],
-  'Conjunction phrase', ['', '', 'CONJP', '', '', 'Ssub'],
-  'Fragment', ['', '', 'FRAG', '', '', ''],
-  'Interjectional phrase', ['', '', 'INTJ', '', '', ''],
-  'List marker', ['', '', 'LST', '', '', ''],
-  'Not a phrase', ['', '', 'NAC', '', '', ''],
-  'Noun phrase', ['', '', 'NP', '', '', 'NP'],
-  'Verbal nucleus',  ['', '', '', '', '', 'VN'],
-  'Head of noun phrase', ['', '', 'NX', '', '', ''],
-  'Prepositional phrase', ['', '', 'PP', '', '', 'PP'],
-  'Parenthetical', ['', '', 'PRN', '', '', ''],
-  'Particle', ['', '', 'PRT', '', '', ''],
-  'Participial phrase', ['', '', '', '', '', 'VPart'],
-  'Quantifier phrase', ['', '', 'QP', '', '', ''],
-  'Relative clause', ['', '', 'RRC', '', '', 'Srel'],
-  'Coordinated phrase', ['', '', 'UCP', '', '', 'COORD'],
-  'Infinitival phrase', ['', '', '', '', '', 'VPinf'], 
-  'Verb phrase', ['', '', 'VP', '', '', ''],
-  'Wh adjective phrase', ['', '', 'WHADJP', '', '', ''],
-  'Wh adverb phrase', ['', '', 'WHAVP', '', '', ''],
-  'Wh noun phrase', ['', '', 'WHNP', '', '', ''],
-  'Wh prepositional phrase', ['', '', 'WHPP', '', '', ''],
-  'Unknown', ['', '', 'X', '', '', ''],
-  'Phrase', ['', '', 'P', '', '', 'Sint'],
-  'Sentence', ['', '', 'S', '', '', 'SENT'],
-  'Phrase', ['', '', 'SBAR', '', '', ''] # Fix
-],
-word_tags: [
-  
-  # Aligned tags for the Claws C5, Brown and Penn tag sets.
-  # Adapted from Manning, Christopher and Schütze, Hinrich,
-  # 1999. Foundations of Statistical Natural Language
-  # Processing. MIT Press, p. 141-142;
-  # http://www.isocat.org/rest/dcs/376;
-
-  'Adjective', ['AJ0', 'JJ', 'JJ', '', 'JJ', 'A'],
-  'Adjective', ['AJ0', 'JJ', 'JJ', '', 'JJ', 'ADJ'],
-  'Ajective, adverbial or predicative', ['', '', '', 'ADJD', '', 'ADJ'],
-  'Adjective, attribute', ['', '', '', 'ADJA', 'VA', 'ADJ'],
-  'Adjective, ordinal number', ['ORD', 'OD', 'JJ', '', 'OD', 'ADJ'],
-  'Adjective, comparative', ['AJC', 'JJR', 'JJR', 'KOKOM', '', 'ADJ'],
-  'Adjective, superlative', ['AJS', 'JJT', 'JJS', '', 'JJ', 'ADJ'],
-  'Adjective, superlative, semantically', ['AJ0', 'JJS', 'JJ', '', '', 'ADJ'],
-  'Adjective, cardinal number', ['CRD', 'CD', 'CD', 'CARD', 'CD', 'ADJ'],
-  'Adjective, cardinal number, one', ['PNI', 'CD', 'CD', 'CARD', 'CD', 'ADJ'],
-
-  'Adverb', ['AV0', 'RB', 'RB', 'ADV', 'AD', 'ADV'],
-  'Adverb, negative', ['XX0', '*', 'RB', 'PTKNEG', '', 'ADV'],
-  'Adverb, comparative', ['AV0', 'RBR', 'RBR', '', 'AD', 'ADV'],
-  'Adverb, superlative', ['AV0', 'RBT', 'RBS', '', 'AD', 'ADV'],
-  'Adverb, particle', ['AVP', 'RP', 'RP', '', '', 'ADV'],
-  'Adverb, question', ['AVQ', 'WRB', 'WRB', '', 'AD', 'ADV'],
-  'Adverb, degree & question', ['AVQ', 'WQL', 'WRB', '', 'ADV'],
-  'Adverb, degree', ['AV0', 'QL', 'RB', '', '', 'ADV'],
-  'Adverb, degree, postposed', ['AV0', 'QLP', 'RB', '', '', 'ADV'],
-  'Adverb, nominal', ['AV0', 'RN', 'RB', 'PROP', '', 'ADV'],
-  'Adverb, pronominal', ['', '', '', '', 'PROP', '', 'ADV'],
-
-  'Conjunction, coordination', ['CJC', 'CC', 'CC', 'KON', 'CC', 'COOD'],
-  'Conjunction, coordination, and', ['CJC', 'CC', 'CC', 'KON', 'CC', 'ET'],
-  'Conjunction, subordination', ['CJS', 'CS', 'IN', 'KOUS', 'CS', 'CONJ'],
-  'Conjunction, subordination with to and infinitive', ['', '', '', 'KOUI', '', ''],
-  'Conjunction, complementizer, that', ['CJT', 'CS', 'IN', '', '', 'C'],
-
-  'Determiner', ['DT0', 'DT', 'DT', '', 'DT', 'D'],
-  'Determiner, pronoun', ['DT0', 'DTI', 'DT', '', '', 'D'],
-  'Determiner, pronoun, plural', ['DT0', 'DTS', 'DT', '', '', 'D'],
-  'Determiner, prequalifier', ['DT0', 'ABL', 'DT', '', '', 'D'],
-  'Determiner, prequantifier', ['DT0', 'ABN', 'PDT', '', 'DT', 'D'],
-  'Determiner, pronoun or double conjunction', ['DT0', 'ABX', 'PDT', '', '', 'D'],
-  'Determiner, pronoun or double conjunction', ['DT0', 'DTX', 'DT', '', '', 'D'],
-  'Determiner, article', ['AT0', 'AT', 'DT', 'ART', '', 'D'],
-  'Determiner, postdeterminer', ['DT0', 'AP', 'DT', '', '', 'D'],
-  'Determiner, possessive', ['DPS', 'PP$', 'PRP$', '', '', 'D'],
-  'Determiner, possessive, second', ['DPS', 'PP$', 'PRPS', '', '', 'D'],
-  'Determiner, question', ['DTQ', 'WDT', 'WDT', '', 'DT', 'D'],
-  'Determiner, possessive & question', ['DTQ', 'WP$', 'WP$', '', '', 'D'],
-  'Interjection', ['', '', '', '', '', 'I'],
-  'Localizer', ['', '', '', '', 'LC'],
-
-  'Measure word', ['', '', '', '', 'M'],
-
-  'Noun, common', ['NN0', 'NN', 'NN', 'N', 'NN', 'NN'],
-  'Noun, singular', ['NN1', 'NN', 'NN', 'NN', 'NN', 'N'],
-  'Noun, plural', ['NN2', 'NNS', 'NNS', 'NN', 'NN', 'N'],
-  'Noun, proper, singular', ['NP0', 'NP', 'NNP', 'NE', 'NR', 'N'],
-  'Noun, proper, plural', ['NP0', 'NPS', 'NNPS', 'NE', 'NR', 'N'],
-  'Noun, adverbial', ['NN0', 'NR', 'NN', 'NE', '', 'N'],
-  'Noun, adverbial, plural', ['NN2', 'NRS', 'NNS', '', 'N'],
-  'Noun, temporal', ['', '', '', '', 'NT', 'N'],
-  'Noun, verbal', ['', '', '', '', 'NN', 'N'],
-
-  'Pronoun, nominal (indefinite)', ['PNI', 'PN', 'PRP', '', 'PN', 'CL'],
-  'Pronoun, personal, subject', ['PNP', 'PPSS', 'PRP', 'PPER'],
-  'Pronoun, personal, subject, 3SG', ['PNP', 'PPS', 'PRP', 'PPER'],
-  'Pronoun, personal, object', ['PNP', 'PPO', 'PRP', 'PPER'],
-  'Pronoun, reflexive', ['PNX', 'PPL', 'PRP', 'PRF'],
-  'Pronoun, reflexive, plural', ['PNX', 'PPLS', 'PRP', 'PRF'],
-  'Pronoun, question, subject', ['PNQ', 'WPS', 'WP', 'PWAV'],
-  'Pronoun, question, subject', ['PNQ', 'WPS', 'WPS', 'PWAV'],  # Hack
-  'Pronoun, question, object', ['PNQ', 'WPO', 'WP', 'PWAV', 'PWAT'],
-  'Pronoun, existential there', ['EX0', 'EX', 'EX'],
-  'Pronoun, attributive demonstrative', ['', '', '', 'PDAT'],
-  'Prounoun, attributive indefinite without determiner', ['', '', '', 'PIAT'],
-  'Pronoun, attributive possessive', ['', '', '', 'PPOSAT', ''],
-  'Pronoun, substituting demonstrative', ['', '', '', 'PDS'],
-  'Pronoun, substituting possessive', ['', '', '', 'PPOSS', ''],
-  'Prounoun, substituting indefinite', ['', '', '', 'PIS'],
-  'Pronoun, attributive relative', ['', '', '', 'PRELAT', ''],
-  'Pronoun, substituting relative', ['', '', '', 'PRELS', ''],
-  'Pronoun, attributive interrogative', ['', '', '', 'PWAT'],
-  'Pronoun, adverbial interrogative', ['', '', '', 'PWAV'],
-
-  'Pronoun, substituting interrogative', ['', '', '', 'PWS'],
-  'Verb, main, finite', ['', '', '', 'VVFIN', '', 'V'],
-  'Verb, main, infinitive', ['', '', '', 'VVINF', '', 'V'],
-  'Verb, main, imperative', ['', '', '', 'VVIMP', '', 'V'],
-  'Verb, base present form (not infinitive)', ['VVB', 'VB', 'VBP', '', '', 'V'],
-  'Verb, infinitive', ['VVI', 'VB', 'VB', 'V', '', 'V'],
-  'Verb, past tense', ['VVD', 'VBD', 'VBD', '', '', 'V'],
-  'Verb, present participle', ['VVG', 'VBG', 'VBG', 'VAPP', '', 'V'],
-  'Verb, past/passive participle', ['VVN', 'VBN', 'VBN', 'VVPP', '', 'V'],
-  'Verb, present, 3SG, -s form', ['VVZ', 'VBZ', 'VBZ', '', '', 'V'],
-  'Verb, auxiliary', ['', '', '', 'VAFIN', '', 'V'],
-  'Verb, imperative', ['', '', '', 'VAIMP', '', 'V'],
-  'Verb, imperative infinitive', ['', '', '', 'VAINF', '', 'V'],
-  'Verb, auxiliary do, base', ['VDB', 'DO', 'VBP', '', '', 'V'],
-  'Verb, auxiliary do, infinitive', ['VDB', 'DO', 'VB', '', '', 'V'],
-  'Verb, auxiliary do, past', ['VDD', 'DOD', 'VBD', '', '', 'V'],
-  'Verb, auxiliary do, present participle', ['VDG', 'VBG', 'VBG', '', '', 'V'],
-  'Verb, auxiliary do, past participle', ['VDN', 'VBN', 'VBN', '', '', 'V'],
-  'Verb, auxiliary do, present 3SG', ['VDZ', 'DOZ', 'VBZ', '', '', 'V'],
-  'Verb, auxiliary have, base', ['VHB', 'HV', 'VBP', 'VA', '', 'V'],
-  'Verb, auxiliary have, infinitive', ['VHI', 'HV', 'VB', 'VAINF', '', 'V'],
-  'Verb, auxiliary have, past', ['VHD', 'HVD', 'VBD', 'VA', '', 'V'],
-  'Verb, auxiliary have, present participle', ['VHG', 'HVG', 'VBG', 'VA', '', 'V'],
-  'Verb, auxiliary have, past participle', ['VHN', 'HVN', 'VBN', 'VAPP', '', 'V'],
-  'Verb, auxiliary have, present 3SG', ['VHZ', 'HVZ', 'VBZ', 'VA', '', 'V'],
-  'Verb, auxiliary be, infinitive', ['VBI', 'BE', 'VB', '', '', 'V'],
-  'Verb, auxiliary be, past', ['VBD', 'BED', 'VBD', '', '', 'V'],
-  'Verb, auxiliary be, past, 3SG', ['VBD', 'BEDZ', 'VBD', '', '', 'V'],
-  'Verb, auxiliary be, present participle', ['VBG', 'BEG', 'VBG', '', '', 'V'],
-  'Verb, auxiliary be, past participle', ['VBN', 'BEN', 'VBN', '', '', 'V'],
-  'Verb, auxiliary be, present, 3SG', ['VBZ', 'BEZ', 'VBZ', '', '', 'V'],
-  'Verb, auxiliary be, present, 1SG', ['VBB', 'BEM', 'VBP', '', '', 'V'],
-  'Verb, auxiliary be, present', ['VBB', 'BER', 'VBP', '', '', 'V'],
-  'Verb, modal', ['VM0', 'MD', 'MD', 'VMFIN', 'VV', 'V'],
-  'Verb, modal', ['VM0', 'MD', 'MD', 'VMINF', 'VV', 'V'],
-  'Verb, modal, finite', ['', '', '', '', 'VMFIN', 'V'],
-  'Verb, modal, infinite', ['', '', '', '', 'VMINF', 'V'],
-  'Verb, modal, past participle', ['', '', '', '', 'VMPP', 'V'],
-
-  'Particle', ['', '', '', '', '', 'PRT'],
-  'Particle, with adverb', ['', '', '', 'PTKA', '', 'PRT'],
-  'Particle, answer', ['', '', '', 'PTKANT', '', 'PRT'],
-  'Particle, negation', ['', '', '', 'PTKNEG', '', 'PRT'],
-  'Particle, separated verb', ['', '', '', 'PTKVZ', '', 'PRT'],
-  'Particle, to as infinitive marker', ['TO0', 'TO', 'TO', 'PTKZU', '', 'PRT'],
-
-  'Preposition, comparative', ['', '', '', 'KOKOM', '', 'P'],
-  'Preposition, to', ['PRP', 'IN', 'TO', '', '', 'P'],
-  'Preposition', ['PRP', 'IN', 'IN', 'APPR', 'P', 'P'],
-  'Preposition, with aritcle', ['', '', '', 'APPART', '', 'P'],
-  'Preposition, of', ['PRF', 'IN', 'IN', '', '', 'P'],
-
-  'Possessive', ['POS', '$', 'POS'],
-
-  'Postposition', ['', '', '', 'APPO'],
-
-  'Circumposition, right', ['', '', '', 'APZR', ''],
-
-  'Interjection, onomatopoeia or other isolate', ['ITJ', 'UH', 'UH', 'ITJ', 'IJ'],
-
-  'Onomatopoeia', ['', '', '', '', 'ON'],
-
-  'Punctuation', ['', '', '', '', 'PU', 'PN'],
-  'Punctuation, sentence ender', ['PUN', '.', '.', '', '', 'PN'],
-
-  'Punctuation, semicolon', ['PUN', '.', '.', '', '', 'PN'],
-  'Puncutation, colon or ellipsis', ['PUN', ':', ':'],
-  'Punctuationm, comma', ['PUN', ',', ',', '$,'],
-  'Punctuation, dash', ['PUN', '-', '-'],
-  'Punctuation, dollar sign', ['PUN', '', '$'],
-  'Punctuation, left bracket', ['PUL', '(', '(', '$('],
-  'Punctuation, right bracket', ['PUR', ')', ')'],
-  'Punctuation, quotation mark, left', ['PUQ', '', '``'],
-  'Punctuation, quotation mark, right', ['PUQ', '', '"'],
-
-  'Punctuation, left bracket', ['PUL', '(', 'PPL'],
-  'Punctuation, right bracket', ['PUR', ')', 'PPR'],
-  'Punctuation, left square bracket', ['PUL', '(', 'LSB'],
-  'Punctuation, right square bracket', ['PUR', ')', 'RSB'],
-  'Punctuation, left curly bracket', ['PUL', '(', 'LCB'],
-  'Punctuation, right curly bracket', ['PUR', ')', 'RCB'],
-
-  'Unknown, foreign words (not in lexicon)', ['UNZ', '(FW-)', 'FW', '', 'FW'],
-
-  'Symbol', ['', '', 'SYM', 'XY'],
-  'Symbol, alphabetical', ['ZZ0', '', ''],
-  'Symbol, list item', ['', '', 'LS'],
-
-  # Not sure about these tags from the Chinese PTB.
-  'Aspect marker', ['', '', '', '', 'AS'],                         # ?
-  'Ba-construction', ['', '', '', '', 'BA'],                       # ?
-  'In relative', ['', '', '', '', 'DEC'],                          # ?
-  'Associative', ['', '', '', '', 'DER'],                          # ?
-  'In V-de or V-de-R construct', ['', '', '', '', 'DER'],          # ?
-  'For words ? ', ['', '', '', '', 'ETC'],                         # ?
-  'In long bei-construct', ['', '', '', '', 'LB'],                 # ?
-  'In short bei-construct', ['', '', '', '', 'SB'],                # ?
-  'Sentence-nal particle', ['', '', '', '', 'SB'],                 # ?
-  'Particle, other', ['', '', '', '', 'MSP'],                      # ?
-  'Before VP', ['', '', '', '', 'DEV'],                            # ?
-  'Verb, ? as main verb', ['', '', '', '', 'VE'],                  # ?
-  'Verb, ????', ['', '', '', '', 'VC']                             # ?
-]}

data/lib/treat/config/tags/enju.rb

@@ -1,71 +0,0 @@
-{cat_to_category: {
-  'ADJ' => 'adjective',
-  'ADV' => 'adverb',
-  'CONJ' => 'conjunction',
-  'COOD' => 'conjunction',
-  'C' => 'complementizer',
-  'D' => 'determiner',
-  'N' => 'noun',
-  'P' => 'preposition',
-  'PN' => 'punctuation',
-  'SC' => 'conjunction',
-  'V' => 'verb',
-  'PRT' => 'particle'
-},
-cat_to_description: [
-  ['ADJ',	'Adjective'],
-  ['ADV',	'Adverb'],
-  ['CONJ',	'Coordination conjunction'],
-  ['C',	'Complementizer'],
-  ['D',	'Determiner'],
-  ['N',	'Noun'],
-  ['P',	'Preposition'],
-  ['SC',	'Subordination conjunction'],
-  ['V',	'Verb'],
-  ['COOD',	'Part of coordination'],
-  ['PN',	'Punctuation'],
-  ['PRT',	'Particle'],
-  ['S',	'Sentence']  
-],
-xcat_to_description: [
-  ['COOD',	'Coordinated phrase/clause'],
-  ['IMP',	'Imperative sentence'],
-  ['INV',	'Subject-verb inversion'],
-  ['Q',	'Interrogative sentence with subject-verb inversion'],
-  ['REL',	'A relativizer included'],
-  ['FREL', 'A free relative included'],
-  ['TRACE',	'A trace included'],
-  ['WH', 'A wh-question word included']
-],
-xcat_to_ptb: [
-  ['ADJP', '', 'ADJP'],
-  ['ADJP', 'REL', 'WHADJP'],
-  ['ADJP', 'FREL', 'WHADJP'],
-  ['ADJP', 'WH', 'WHADJP'],
-  ['ADVP', '', 'ADVP'],
-  ['ADVP', 'REL', 'WHADVP'],
-  ['ADVP', 'FREL', 'WHADVP'],
-  ['ADVP', 'WH', 'WHADVP'],
-  ['CONJP', '', 'CONJP'],
-  ['CP', '', 'SBAR'],
-  ['DP', '', 'NP'],
-  ['NP', '', 'NP'],
-  ['NX', 'NX', 'NAC'],
-  ['NP'	'REL'	'WHNP'],
-  ['NP'	'FREL'	'WHNP'],
-  ['NP'	'WH'	'WHNP'],
-  ['PP', '', 'PP'],
-  ['PP', 'REL', 'WHPP'],
-  ['PP', 'WH', 'WHPP'],
-  ['PRT', '', 'PRT'],
-  ['S', '', 'S'],
-  ['S', 'INV', 'SINV'],
-  ['S', 'Q', 'SQ'],
-  ['S', 'REL', 'SBAR'],
-  ['S', 'FREL', 'SBAR'],
-  ['S', 'WH', 'SBARQ'],
-  ['SCP', '', 'SBAR'],
-  ['VP', '', 'VP'],
-  ['VP', '', 'VP'],
-  ['', '', 'UK']
-]}

data/lib/treat/config/tags/paris7.rb

@@ -1,17 +0,0 @@
-{tag_to_category: {
-  'C' => :complementizer,
-  'PN' => :punctuation,
-  'SC' => :conjunction
-}
-# Paris7 Treebank functional tags
-=begin
-SUJ (subject)
-OBJ (direct object)
-ATS (predicative complement of a subject)
-ATO (predicative complement of a direct object)
-MOD (modifier or adjunct)
-A-OBJ (indirect complement introduced by à)
-DE-OBJ (indirect complement introduced by de)
-P-OBJ (indirect complement introduced by another preposition)
-=end
-}

data/lib/treat/config/tags/ptb.rb

@@ -1,15 +0,0 @@
-{escape_characters: {
-  '(' => '-LRB-',
-  ')' => '-RRB-',
-  '[' => '-LSB-',
-  ']' => '-RSB-',
-  '{' => '-LCB-',
-  '}' => '-RCB-'
-},
-phrase_tag_to_description: [
-  ['S', 'Paris7 declarative clause'],
-  ['SBAR', 'Clause introduced by a (possibly empty) subordinating conjunction'],
-  ['SBARQ', 'Direct question introduced by a wh-word or a wh-phrase'],
-  ['SINV', 'Inverted declarative sentence'],
-  ['SQ', 'Inverted yes/no question']
-]}

data/lib/treat/config/workers/list.rb

@@ -1 +0,0 @@
-[:extractors, :inflectors, :formatters, :learners, :lexicalizers, :processors, :retrievers]

data/lib/treat/config.rb

@@ -1,135 +0,0 @@
-module Treat::Config
-
-  Paths = [ :tmp, :lib, :bin, 
-  :files, :data, :models, :spec ]
-
-  class << self
-    attr_accessor :config
-  end
-
-  Treat.module_eval do
-    # Handle all missing methods as conf options.
-    def self.method_missing(sym, *args, &block)
-      super(sym, *args, &block) if sym == :to_ary
-      Treat::Config.config[sym]
-    end
-  end
-
-  def self.configure
-    # Temporary configuration hash.
-    config = { paths: {} }
-    confdir = get_full_path(:lib) + 'treat/config'
-    # Iterate over each directory in the config.
-    Dir[confdir + '/*'].each do |dir|
-      name = File.basename(dir, '.*').intern
-      config[name] = {}
-      # Iterate over each file in the directory.
-      Dir[confdir + "/#{name}/*.rb"].each do |file|
-        key = File.basename(file, '.*').intern
-        config[name][key] = eval(File.read(file))
-      end
-    end
-    # Get the path config.
-    Paths.each do |path|
-      config[:paths][path] = get_full_path(path)
-    end
-    # Get the tag alignments.
-    configure_tags!(config[:tags][:aligned])
-    # Convert hash to structs.
-    self.config = self.hash_to_struct(config)
-  end
-
-  def self.get_full_path(dir)
-    File.dirname(__FILE__) +
-    '/../../' + dir.to_s + "/"
-  end
-  
-  def self.configure_tags!(config)
-    ts = config[:tag_sets]
-    config[:word_tags_to_category] = 
-    align_tags(config[:word_tags], ts)
-    config[:phrase_tags_to_category] =
-    align_tags(config[:phrase_tags], ts)
-  end
-
-  # Align tag configuration.
-  def self.align_tags(tags, tag_sets)
-    wttc = {}
-    tags.each_slice(2) do |desc, tags|
-      category = desc.gsub(',', ' ,').
-      split(' ')[0].downcase
-      tag_sets.each_with_index do |tag_set, i|
-        next unless tags[i]
-        wttc[tags[i]] ||= {}
-        wttc[tags[i]][tag_set] = category
-      end
-    end
-    wttc
-  end
-  
-  def self.hash_to_struct(hash)
-    return hash if hash.keys.
-    select { |k| !k.is_a?(Symbol) }.size > 0
-    struct = Struct.new(
-    *hash.keys).new(*hash.values)
-    hash.each do |key, value|
-      if value.is_a?(Hash)
-        struct[key] =
-        self.hash_to_struct(value)
-      end
-    end
-    struct
-  end
-
-  # Turn on syntactic sugar.
-  def self.sweeten!
-    
-    # Undo this in unsweeten! - # Fix
-    Treat::Entities.module_eval do 
-      self.constants.each do |type|
-        define_singleton_method(type) do |value='', id=nil|
-          const_get(type).build(value, id)
-        end
-      end
-    end
-    
-    return if Treat.core.syntax.sweetened
-    Treat.core.syntax.sweetened = true
-    Treat.core.entities.list.each do |type|
-      next if type == :Symbol
-      kname = cc(type).intern
-      klass = Treat::Entities.const_get(kname)
-      Object.class_eval do
-        define_method(kname) do |val, opts={}|
-          klass.build(val, opts)
-        end
-      end
-    end
-    
-    Treat::Core.constants.each do |kname|
-      Object.class_eval do
-        klass = Treat::Core.const_get(kname)
-        define_method(kname) do |*args|
-          klass.new(*args)
-        end
-      end
-    end
-    
-  end
-
-  # Turn off syntactic sugar.
-  def self.unsweeten!
-    return unless Treat.core.syntax.sweetened
-    Treat.core.syntax.sweetened = false
-    Treat.core.entities.list.each do |type|
-      name = cc(type).intern
-      next if type == :Symbol
-      Object.class_eval { remove_method(name) }
-    end
-
-  end
-
-  # Run all configuration.
-  self.configure
-
-end

data/lib/treat/core.rb

@@ -1,5 +0,0 @@
-# Contains the core classes used by Treat.
-module Treat::Core
-  p = Treat.paths.lib + 'treat/core/*.rb'
-  Dir.glob(p).each { |f| require f }
-end

data/lib/treat/entities/abilities/copyable.rb

@@ -1,47 +0,0 @@
-module Treat::Entities::Abilities::Copyable
-  
-  require 'fileutils'
-  
-  # What happens when it is a database-stored
-  # collection or document ?
-  def copy_into(collection)
-    unless collection.is_a?(
-    Treat::Entities::Collection)
-      raise Treat::Exception,
-      "Cannot copy an entity into " +
-      "something else than a collection."
-    end
-    if type == :document
-      copy_document_into(collection)
-    elsif type == :collection
-      copy_collection_into(collection)
-    else
-      raise Treat::Exception,
-      "Can only copy a document " +
-      "or collection into a collection."
-    end
-  end
-  
-  def copy_collection_into(collection)
-    copy = dup
-    f = File.dirname(folder)
-    f = f.split(File::SEPARATOR)[-1]
-    f = File.join(collection.folder, f)
-    FileUtils.mkdir(f) unless
-    FileTest.directory(f)
-    FileUtils.cp_r(folder, f)
-    copy.set :folder, f
-    copy
-  end
-  
-  def copy_document_into(collection)
-    copy = dup
-    return copy unless file
-    f = File.basename(file)
-    f = File.join(collection.folder, f)
-    FileUtils.cp(file, f)
-    copy.set :file, f
-    copy
-  end
-
-end

data/lib/treat/entities/abilities/debuggable.rb

@@ -1,83 +0,0 @@
-# When Treat.debug is set to true, each call to
-# #call_worker will result in a debug message being
-# printed by the #print_debug function.
-module Treat::Entities::Abilities::Debuggable
-  
-  @@prev = nil
-  @@i = 0
-
-  # Explains what Treat is currently doing.
-  def print_debug(entity, task, worker, group, options)
-
-    targs = group.targets.map do |target|
-      target.to_s
-    end
-    
-    if targs.size == 1
-      t = targs[0]
-    else
-      t = targs[0..-2].join(', ') +
-      ' and/or ' + targs[-1]
-    end
-
-    genitive = targs.size > 1 ?
-    'their' : 'its'
-
-    doing = ''
-
-    human_task = task.to_s.gsub('_', ' ')
-
-    if group.type == :transformer ||
-      group.type == :computer
-      
-      tt = human_task
-      tt = tt[0..-2] if tt[-1] == 'e'
-      ed = tt[-1] == 'd' ? '' : 'ed'
-      doing = "#{tt.capitalize}#{ed} #{t}"
-      
-    elsif group.type == :annotator
-
-      if group.preset_option
-        opt = options[group.preset_option]
-        form = opt.to_s.gsub('_', ' ')
-        human_task[-1] = ''
-        human_task = form + ' ' + human_task
-      end
-
-      doing = "Annotated #{t} with " +
-      "#{genitive} #{human_task}"
-    end
-    
-    if group.to_s.index('Formatters')
-      curr = doing +
-      ' in format ' +
-      worker.to_s
-    else
-      curr = doing +
-      ' using ' +
-      worker.to_s.gsub('_', ' ')
-    end
-    
-    curr.gsub!('ss', 's') unless curr.index('class')
-    curr += '.'
-    
-    if curr == @@prev
-      @@i += 1
-    else
-      if @@i > 1
-        Treat.core.entities.list.each do |e|
-          @@prev.gsub!(e.to_s, e.to_s + 's')
-        end
-        @@prev.gsub!('its', 'their')
-        @@prev = @@prev.split(' ').
-        insert(1, @@i.to_s).join(' ')
-      end
-      @@i = 0
-      puts @@prev     # Last call doesn't get shown.
-    end
-    
-    @@prev = curr
-  
-  end
-  
-end

data/lib/treat/entities/abilities/registrable.rb

@@ -1,46 +0,0 @@
-# Registers occurences of textual values inside
-# all children entity. Useful to calculate frequency.
-module Treat::Entities::Abilities::Registrable
-
-  # Registers a token in the @registry hash.
-  def register(entity)
-    
-    unless @registry
-      @count = 0
-      @registry = {
-        :value => {}, 
-        :position => {}, 
-        :type => {}, 
-        :id => {}
-      }
-    end
-    
-    if entity.is_a?(Treat::Entities::Token) ||
-      entity.is_a?(Treat::Entities::Phrase)
-      val = entity.to_s.downcase
-      @registry[:value][val] ||= 0
-      @registry[:value][val] += 1
-    end
-  
-    @registry[:id][entity.id] = true
-    @registry[:type][entity.type] ||= 0
-    @registry[:type][entity.type] += 1
-    @registry[:position][entity.id] = @count
-    @count += 1
-    
-    @parent.register(entity) if has_parent?
-    
-  end
-
-  # Backtrack up the tree to find a token registry,
-  # by default the one in the root node of any entity.
-  def registry(type = nil)
-    if has_parent? &&
-      type != self.type
-      @parent.registry(type)
-    else
-      @registry
-    end
-  end
-
-end