dunmanifestin 1.1.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e08fd19462f956e116b9fc58b7a00e8988afcc391947b2321a925249c2602458
-  data.tar.gz: 344b6336a1c3303dd8f4ffc88cc82e37c107e34db95f89b67fbd66fd546704f5
+  metadata.gz: fe034e91906b9ceaa0c86e037a01edfb69ad6c737ab9fdbb626becd610bc234b
+  data.tar.gz: 820efff91dd927269b89fee2462747d303870b97b3648957c20c524768da0b30
 SHA512:
-  metadata.gz: eaf0fa4b3433ed699741da6b557071d33b576c142899c402181f7b5cdf219fa619f693243f043019018aa05e8ee118fe97f065b76c0df192b1e4ca49254039d1
-  data.tar.gz: 47281b79a2d37d99144ea58b90a50730ccb97a15274a66bf5dcb8b150cc637ab5f3a279158174027389b1e3c3f3a2346f5f0d062df4012be7cae6e2ad9233f6c
+  metadata.gz: 0a0bfbe9e373a9ae7730a5d1db22bd6b4fbbe46e4fe69a9cdaefe7e15b70f913d12c4bf45ae9dc51b5575ddb0c1ebe61e9bddf8aaf3346d67de380807be6f006
+  data.tar.gz: 40ee4e7f6a31d3310af75923e9dd5d34fbad1698bbe5703801de62189d07236886d8ad5c60c0de7181fd305b03010d096640068387787837b415097ea9e519c8

data/bin/dunmanifestin

@@ -12,8 +12,6 @@ user_demands = Optimist::options do
   opt :phrase, "Specify a phrase or list, e.g. 'The [animal] sat on the [article]' or '[weapon]'", type: :string, short: '-p'
   opt :chomp, "remove the trailing newline from the output", short: '-o'
   opt :file, "Read a file as the phrase", type: :string, short: '-f'
-  opt :coarse_seed, "Set this number to encourage phrases to resolve  somewhat predictably", type: :integer, short: "-s"
-  opt :fine_seed, "Set this number (alongside -s) to lock phrases into resolving completely predictably", type: :integer, short: "-e"
 end
 
 begin

data/lib/dunmanifestin.rb

@@ -7,5 +7,4 @@ require_relative 'dunmanifestin/string'
 require_relative 'dunmanifestin/custom_inflections'
 require_relative 'dunmanifestin/phrase'
 require_relative 'dunmanifestin/manifestation'
-require_relative 'dunmanifestin/list_loader'
 require_relative 'dunmanifestin/terminator'

data/lib/dunmanifestin/array.rb

@@ -1,30 +1,9 @@
-require_relative 'integer'
-
 class Array
-
-
-  class << self
-    attr_accessor :coarse_seed, :fine_seed, :diversity, :recurrences
-
-    def meta_random
-      @meta_random ||= @fine_seed ? Random.new(@fine_seed) : Random.new
-    end
-
-    def randoms
-      @coarse_seed ||= meta_random.rand(Integer::MAX)
-      @recurrences ||= 500
-      @randoms ||= @recurrences.times.map do |i|
-        Random.new(@coarse_seed + (i % (@diversity||Integer::MAX)))
-      end
-    end
+  def even_elements
+    select.each_with_index { |_, i| i.even? }
   end
 
-  def constrained_sample(randoms: Array.randoms, meta_random: Array.meta_random)
-    # $count ||= 1
-    # p $count += 1
-    self.sample(
-      1,
-      random: randoms.sample(1, random: meta_random).pop
-    ).pop
+  def odd_elements
+    select.each_with_index { |_, i| i.odd? }
   end
 end

data/lib/dunmanifestin/churn.rb

@@ -0,0 +1,35 @@
+class Churn
+  # A churn is a data structure that stores a set of things.
+  # You can randomly pick one of those things by calling its
+  # sample() method.
+  #
+  # The wrinkle is that the set of sampleable things is not
+  # closed. The churn will sometimes, at random, generate a
+  # totally new item. You can also explicitly request a
+  # novel item by calling generate(). Any new items
+  # generated are added to the churn and may be picked on
+  # future calls to sample().
+  #
+  # Control how often the churn generates new things using
+  # the novelty: parameter to initialize().
+
+  def initialize novelty:
+    @novelty = novelty
+    @generated = 0
+    @slots = {}
+  end
+
+  def sample
+    return yield if @novelty == 0
+    r = (rand * (@novelty + @slots.length)).floor
+    @slots[r] ||= yield
+  end
+
+  def generate
+    return yield if @novelty == 0
+    @slots[@generated] ||= yield
+    value = @slots[@generated]
+    @generated += 1
+    value
+  end
+end

data/lib/dunmanifestin/custom_inflections.rb

@@ -2,5 +2,6 @@ require 'active_support/inflector'
 
 ActiveSupport::Inflector.inflections do |inflect|
   inflect.irregular 'human', 'humans'
+  inflect.irregular 'leaf', 'leaves'
   inflect.plural /^(.+)z$/, '\0es'
 end

data/lib/dunmanifestin/genre.rb

@@ -0,0 +1,31 @@
+class Genre
+  GAP_BETWEEN_PALETTES   = /\n(?=\|)/
+
+  def self.from_directories paths
+    new palettes_from paths
+  end
+
+  def self.palettes_from paths
+    paths.flat_map do |path|
+      Dir[File.join(path, '**', '*.pal')].flat_map do |filename|
+        File.read(filename)
+          .split(GAP_BETWEEN_PALETTES)
+          .map do |textual_palette|
+            Palette.new(textual_palette, filename)
+          end
+      end
+    end
+  end
+
+  def initialize palette_list
+    self.palettes = Hash[palette_list.map { |p| [p.name, p] }]
+  end
+
+  def palette_named name
+    palettes[name] || NullPalette.new(name)
+  end
+
+
+
+  attr_accessor :palettes
+end

data/lib/dunmanifestin/palette.rb

@@ -1,42 +1,98 @@
+require_relative './phrase'
+require_relative './churn'
+
+class NullPalette
+  def initialize name
+    @name = name
+  end
+
+  def name
+    @name
+  end
+
+  def sample _, _, _
+    "{#{@name} ??}"
+  end
+end
+
 class Palette
-    GAP_BETWEEN_LISTS   = /\n(?=\|)/
-    PALETTE_TITLE       = /^\|(.*?)\n/
-    COMMENT             = /\/\/(.*?)\n/
-  class << self
-    def expose path
-      File.open(path).read
-        .split(GAP_BETWEEN_LISTS)
-        .each &method(:expose_swatches)
-    end
+  GAP_BETWEEN_LISTS   = /\n(?=\|)/
+  PALETTE_TITLE       = /^\|(.*?)\n/
+  COMMENT             = %r{//.*$}
+  REPETITION_PREFIX   = /^\d+@/
+
+  def initialize raw_text, filename
+    @raw_text = raw_text
+    @filename = filename
+  end
 
-    def expose_swatches body
-      body.gsub!(COMMENT, '')
-      list_name = body.match(PALETTE_TITLE)[1].to_s
+  def name
+    return file_basename if not titled?
+    lines.first.sub(/\|(\w+).*$/, '\1')
+  end
 
-      if list_name.empty?
-        # This seems to support palettes without |explicitTitles,
-        #  Taking them from the filename, instead.
-        list_name = Pathname.new(path).basename
+  def sample genre, inflections = [], constraints = []
+    if inflections.any?
+      # don't use the churn if there are inflections, since
+      # the inflected text would be cached by the churn and
+      # could then `recur` in places where we don't want any
+      # inflections.
+      phrases.sample.reify genre, inflections
+    else
+      if constraints.include? :recur
+        churn.sample { phrases.sample.reify genre }
       else
-        # Do not include palette title as a swatch
-        # These comments should be tests.
-        body.gsub!(PALETTE_TITLE, '')
+        churn.generate { phrases.sample.reify genre }
       end
-
-      # This metaprogramming is mysterious to me.
-      qlass = declare_phrase_class list_name
-      # Where is 'list' defined?
-      qlass.list body
-    rescue NoMethodError
     end
+  rescue NoMethodError
+    "{#{name} ??}"
+  end
+
 
-    def declare_phrase_class list_name
-      name = list_name.underscore.camelize
-      qlass = "Phrase::#{name}".constantize
-    rescue NameError
-      # This seems to always happen.
-      qlass = Class.new(Phrase)
-      Phrase.const_set name, qlass
+
+  def file_basename
+    File.basename(@filename, '.pal')
+  end
+
+  def churn
+    @churn ||= Churn.new novelty: novelty
+  end
+
+  def novelty
+    lines.first.sub(/^.*\*(\d+).*$/, '\1').to_i
+  end
+
+  def phrases
+    @phrases ||= begin
+      lines[valid_phrase_range]
+        .map { |line| line.sub(COMMENT, '') }
+        .map(&:strip)
+        .reject(&:empty?)
+        .flat_map { |line|
+          if line =~ REPETITION_PREFIX
+            [line.sub(REPETITION_PREFIX, '')] * line.to_i
+          else
+            [line]
+          end
+        }
+        .map(&Phrase.method(:new))
     end
   end
+
+  def valid_phrase_range
+    titled? ? 1..-1 : 0..-1
+  end
+
+  def lines
+    @lines ||= text.gsub(/>>(.+?)<</m, '').split("\n") | text.scan(/>>(.+?)<</m).flatten
+  end
+
+  def text
+    @text ||= @raw_text.strip
+  end
+
+  def titled?
+    lines[0][0] == '|'
+  end
 end

data/lib/dunmanifestin/phrase.rb

@@ -2,175 +2,115 @@ require 'active_support/inflector'
 require_relative 'custom_inflections'
 require_relative 'array'
 
-class Phrase
-  def self.list new_list = nil, multiline_document = false
-    return (@list || List.new) unless new_list
-
-    new_list = new_list.split_on_newlines_and_strip if new_list.is_a?(String) unless multiline_document
-    new_list = [new_list] if multiline_document
-
-    new_list.map! do |line|
-      multiplier_regex = /^\d+@/
-      multiplier = line.match(multiplier_regex).to_s.to_i
-      multiplier = 1 if multiplier < 1
-      [line.gsub(multiplier_regex, '')] * multiplier
-    end.flatten!.reject! { |i| i.nil? || i.empty? }
+class NullPhrase
+  def initialize dsl_string
+    @dsl_string = dsl_string
+  end
 
-    @list = new_list
+  def reify _, _
+    @dsl_string
   end
+end
 
-  def initialize dsl_string = self.class.list.constrained_sample
+class Phrase
+  def initialize dsl_string
     raise "Try again." unless dsl_string
-    compile parse dsl_string
+    @dsl_string = dsl_string
   end
 
-  def compile parsed_dsl
-    template = parsed_dsl[:template]
-
-    @variable_classes = []
-    @inflection_delegates = {
-      :plural => [],
-      :possessive => [],
-      :article => [],
-      :capitalize => [],
+  def reify genre, requested_inflections = []
+    vals = variables.map { |variable|
+      variable.reify genre, requested_inflections
     }
+    inflect requested_inflections, constant_segments.zip(vals).flatten.join('')
+  end
 
-    inflections = []
-
-    parsed_dsl[:variables].each_with_index do |variable, i|
-      rough_var_class = variable[:rough_variable_class]
+  private
 
-      variable[:inflections_to_delegate].each do |inflection|
-        @inflection_delegates[inflection.to_sym] << i
-      end
+  def variables
+    parsed_dsl[:variables]
+  end
 
-      inflections[i] = []
+  def constant_segments
+    parsed_dsl[:constant_segments]
+  end
 
-      variable[:inflections_to_apply].each do |inflection|
-        inflections[i] << inflection.to_sym
-      end
+  def parsed_dsl
+    @parsed_dsl ||= begin
+      tokens = @dsl_string.split(/[\[\]]/)
+      constant_segments = tokens.even_elements
+      variables         = tokens.odd_elements
 
-      begin
-        @variable_classes << "Phrase::#{rough_var_class.camelize}".constantize
-      rescue NameError
-        @variable_classes << empty_phrase_class(rough_var_class)
-      end
+      {
+        :variables => variables.map(&Variable.method(:new)),
+        :constant_segments => constant_segments
+      }
     end
-
-    @to_s_proc = -> {
-      self.variables.each_with_index do |variable, i|
-        inflections[i].each { |inflection| variable.inflect inflection }
-      end
-      template.zip(self.variables).flatten.map(&:to_s).join('')
-    }
   end
 
-  def parse dsl_string = @dsl_string
-    # A dsl string like "[adjective] [noun.possessive#plural]" will be parsed into
-    # { :variables =>
-    #   [ { :rough_variable_class => 'adjective',
-    #       :inflections_to_delegate => [],
-    #       :inflections_to_apply => []
-    #     },
-    #     { :rough_variable_class => 'noun',
-    #       :inflections_to_delegate => [:plural],
-    #       :inflections_to_apply => [:possessive]
-    #     }
-    #   ],
-    #   :template => ["", " "]
-    # }
-    #
-    tokens = dsl_string.split(/[\[\]]/)
-    template = []; variables = [];
-
-    tokens.each_with_index do |token, i|
-      if i % 2 == 0
-        template << token
-      else
-        variables << token
-      end
-    end
+  def inflect inflections, string
+    plural     = inflections.include? :plural
+    article    = inflections.include? :article
+    possessive = inflections.include? :possessive
+    capitalize = inflections.include? :capitalize
+    titleize   = inflections.include? :titleize
 
-    hash = {:variables => [], :template => template}
+    # Good, now turn this into a stateless function.
+    string = string.pluralize if plural && variables.none?(&:delegated_plural?)
+    string = (string =~ /s$/) ? "#{string}'" : "#{string}'s" if plural && possessive && variables.none?(&:delegated_plural?)
+    string = "#{string}'s" if !plural && possessive && variables.none?(&:delegated_possessive?)
+    string = (string =~ /^[aeiou]/i) ? "an #{string}" : "a #{string}" if !plural && article && variables.none?(&:delegated_article?)
+    string = string[0].capitalize + string[1 .. -1] if capitalize
+    string = string.titleize if titleize
 
-    variables.each_with_index do |variable, i|
-      components = variable.split(/\b/)
-      rough_var_class = components.shift
-      inflections_to_delegate = []
-      inflections_to_apply = []
+    string
+  end
+end
 
-      components.each_with_index do |v, k|
-        inflections_to_delegate << v if components[k-1] == '#'
-        inflections_to_apply << v if components[k-1] == '.'
+class Variable
+  def initialize dsl_string
+    components = dsl_string.split(/\b/)
+    self.palette_name = components.shift
+
+    self.inflections_delegated_to_me = []
+    self.demanded_inflections        = []
+    self.constraints                 = []
+
+    components.each_with_index do |v, k|
+      case components[k-1]
+      when '#'
+        inflections_delegated_to_me << v.to_sym
+      when '.'
+        demanded_inflections << v.to_sym
+      when ':'
+        constraints << v.to_sym
       end
-
-      hash[:variables] << {
-        :rough_variable_class => rough_var_class,
-        :inflections_to_delegate => inflections_to_delegate,
-        :inflections_to_apply => inflections_to_apply,
-      }
     end
-
-    hash
-  end
-
-  def variables
-    @variables ||= @variable_classes.map(&:new)
   end
 
-  def plural?;     !!@plural     end
-  def possessive?; !!@possessive end
-  def article?;    !!@article    end
-  def capitalize?; !!@capitalize end
-  def titleize?;   !!@titleize   end
-
-  def titleize!
-    delegates = @inflection_delegates[:capitalize]
-    delegates.each { |delegate| variables[delegate].capitalize! }
+  def reify genre, inflections_of_parent_phrase
+    inherited_inflections = inflections_of_parent_phrase & inflections_delegated_to_me
+    inflections = demanded_inflections | inherited_inflections
+    genre.palette_named(palette_name).sample genre, inflections, constraints
   end
 
-  def inflect inflection
-    return self unless @inflection_delegates
-    self.instance_variable_set("@#{inflection}", true)
-    return (titleize! && self) if inflection == :titleize
-
-    delegates = @inflection_delegates[inflection]
-    delegates.each { |delegate| variables[delegate].inflect inflection }
-    self
-  rescue NoMethodError
-    puts "==> Failed to inflect: .#{inflection}?"
-    puts "==> Valid inflections are: plural, possessive, article, capitalize, titleize"
-    self
+  def delegated_plural?
+    inflections_delegated_to_me.include? :plural
   end
 
-  def to_s
-    render_inflections @to_s_proc.call
+  def delegated_article?
+    inflections_delegated_to_me.include? :article
   end
 
-  def render_inflections string
-    # Good, now turn this into a stateless function.
-    string = string.pluralize if plural? && @inflection_delegates[:plural].empty?
-    string = (string =~ /s$/) ? "#{string}'" : "#{string}'s" if plural? && possessive? && @inflection_delegates[:possessive].empty?
-    string = "#{string}'s" if !plural? && possessive? && @inflection_delegates[:possessive].empty?
-    string = (string =~ /^[aeiou]/i) ? "an #{string}" : "a #{string}" if !plural? && article? && @inflection_delegates[:article].empty?
-    string = string[0].capitalize + string[1 .. -1] if capitalize?
-    string = string.titleize if titleize?
-
-    string
+  def delegated_possessive?
+    inflections_delegated_to_me.include? :possessive
   end
 
   private
 
-  def empty_phrase_class name
-    class_definition = <<-RUBY
-      Class.new(Phrase) do
-        def initialize
-          @to_s_proc = -> { "{#{name} ??}" }
-        end
-      end
-    RUBY
-
-    eval(class_definition)
-  end
-
+  attr_accessor \
+    :demanded_inflections,
+    :palette_name,
+    :inflections_delegated_to_me,
+    :constraints
 end

data/lib/dunmanifestin/terminator.rb

@@ -1,41 +1,27 @@
+require_relative 'genre'
 require_relative 'phrase'
-require_relative 'list_loader'
-require_relative 'string'
+require_relative 'palette'
 
 class Terminator
-  def initialize(list_loader: ListLoader, shell: Shell)
-    @list_loader = list_loader
+  def initialize(shell: Shell)
     @shell = shell
   end
 
   def address demands
-    Array.coarse_seed = demands[:coarse_seed]
-    Array.fine_seed = demands[:fine_seed]
-    Array.diversity = 2
-    Array.recurrences = 20
-    phrase_string = phrasing(demands[:phrase], demands[:file])
-    root_phrase_class = Class.new(Phrase) { list phrase_string, !!demands[:file] }
-    list_loader.load demands[:genre]
-    print interactive_banner if demands[:interactive]
-
-    construction_loop(
-      root_phrase_class,
-      (demands[:count] || 1),
-      demands[:chomp],
-      demands[:copy],
-      demands[:interactive]
-    )
+    self.demands = demands
+    print interactive_banner if interactive
+    construction_loop
   end
 
   private
-  DEFAULT_ROOT_PHRASEAGE = '[root]'
-  attr_accessor :list_loader, :shell
 
-  def construction_loop root_phrase_class, volume, chomp, copy, interact
+  attr_accessor :shell, :demands
+
+  def construction_loop
     fulltext = ""
     while true
       volume.times do
-        text = root_phrase_class.new.to_s
+        text = Phrase.new(phrasing).reify genre
         fulltext += "\n#{text}"
         text += "\n" unless chomp
         shell.puts text
@@ -43,13 +29,21 @@ class Terminator
 
       `echo #{fulltext.inspect} | pbcopy $1` if copy
 
-      break unless interact
+      break unless interactive
       break if get_from_prompt == 'quit'
     end
   end
 
-  def phrasing given, file
-    given || (!!file && File.read(file)) || DEFAULT_ROOT_PHRASEAGE
+  def genre
+    @genre ||= Genre.from_directories genre_directories
+  end
+
+  def genre_directories
+    ([default_genre_path] + demanded_genres).reject(&:empty?)
+  end
+
+  def phrasing
+    demanded_phrase || demanded_file_contents || '[root]'
   end
 
   def get_from_prompt
@@ -63,6 +57,50 @@ class Terminator
     [bar, message, bar].join "\n"
   end
 
+  def chomp
+    demands[:chomp]
+  end
+
+  def copy
+    demands[:copy]
+  end
+
+  def volume
+    demands[:count] || 1
+  end
+
+  def interactive
+    demands[:interactive]
+  end
+
+  def demanded_genres
+    demands[:genre] ? demands[:genre].split(':') : []
+  end
+
+  def demanded_file
+    demands[:file]
+  end
+
+  def demanded_file_contents
+    demanded_file && File.read(demanded_file)
+  end
+
+  def demanded_phrase
+    demands[:phrase]
+  end
+
+  def coarse_seed
+    demands[:coarse_seed]
+  end
+
+  def fine_seed
+    demands[:fine_seed]
+  end
+
+  def default_genre_path
+    File.join(*%W(#{File.dirname(__FILE__)} .. .. default-genre))
+  end
+
   module Shell
     class << self
       def method_missing method, *args

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: dunmanifestin
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.2.0
 platform: ruby
 authors:
-- quavmo
+- gavmor
 - benchristel
 - AlexLerman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-06 00:00:00.000000000 Z
+date: 2019-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -83,7 +83,7 @@ dependencies:
 description: The point of Dunmanifestin [is] to inject chaos into humans' cliched
   ideas or, at least, let them be hunter-gatherers instead of farmers of culture.
   -- B. Christel
-email: quavmo@gmail.com
+email: morgan.gavin@gmail.com
 executables:
 - dunmanifestin
 extensions: []
@@ -98,18 +98,14 @@ files:
 - default-genre/verb.pal
 - lib/dunmanifestin.rb
 - lib/dunmanifestin/array.rb
+- lib/dunmanifestin/churn.rb
 - lib/dunmanifestin/custom_inflections.rb
-- lib/dunmanifestin/generator.rb
+- lib/dunmanifestin/genre.rb
 - lib/dunmanifestin/integer.rb
-- lib/dunmanifestin/list.rb
-- lib/dunmanifestin/list_loader.rb
-- lib/dunmanifestin/manifestation.rb
-- lib/dunmanifestin/member.rb
 - lib/dunmanifestin/palette.rb
 - lib/dunmanifestin/phrase.rb
-- lib/dunmanifestin/string.rb
 - lib/dunmanifestin/terminator.rb
-homepage: http://github.com/quavmo/dunmanifestin
+homepage: http://github.com/gavmor/dunmanifestin
 licenses:
 - MIT
 metadata: {}

data/lib/dunmanifestin/generator.rb

@@ -1,46 +0,0 @@
-class Generator
-  def self.from_file path
-    new File.open(path).readlines.map(&:chomp).reject { |line| line.empty? }.unshift('root')
-  end
-
-  def initialize lines 
-    lines.inject do |list, line|
-       create_or_append_list(list, line)
-    end
-  end
-
-  def lists
-    @lists ||= {}
-  end
-
-  def generate kind
-    kind = kind.to_s
-    list = lists[kind] || lists['|' + kind]
-    return "{#{kind}?}" unless list
-    list.sample.to_s
-  end
-
-  def manifest phrase
-    phrase.to_s
-    #phrase.listerpolate(self)
-  end
-
-  def method_missing slug
-    generate slug
-  end
-
-  private 
-
-  def create_or_append_list list, line
-    if line.is_name?
-      list = List.new(name: line, universe: self)
-    else
-      list << line
-    end
-
-    list
-  end
-end
-
-class NoSuchList < StandardError
-end

data/lib/dunmanifestin/list.rb

@@ -1,31 +0,0 @@
-class List
-  attr_accessor :name
-
-  def initialize opts={}
-    @name = opts.fetch(:name, 'default')
-    @members = opts.fetch(:members, [])
-    @universe = opts.fetch(:universe)
-    @universe.lists[name] = self
-    puts members
-  end
-
-
-  def << rough_member
-    pieces = rough_member.split('@')
-
-    weight = pieces.length > 1 ? pieces.shift.to_i : 1
-
-    attrs = {body: pieces.pop, list: self, universe: universe}
-    attrs.merge!(frequency: pieces.pop) if pieces.any?
-    member = Member.new(attrs)
-
-    weight.times { members << member }
-  end
-
-  def sample
-    members.sample
-  end
-
-  private
-  attr_accessor :members, :universe
-end

data/lib/dunmanifestin/list_loader.rb

@@ -1,20 +0,0 @@
-require_relative 'phrase'
-require_relative 'string'
-require_relative 'palette'
-
-class ListLoader
-  DEFAULT_GENRE = File.join(*%W(#{File.dirname(__FILE__)} .. .. default-genre))
-
-  class << self
-    def load super_genre=''
-      [DEFAULT_GENRE, (super_genre || '').split(":")]
-        .flatten.compact.each(&method(:load_genre))
-    end
-
-    private
-
-    def load_genre dirname
-      Dir[File.join(dirname, '**' '*.pal')].each(&Palette.method(:expose))
-    end
-  end
-end

data/lib/dunmanifestin/manifestation.rb

@@ -1,30 +0,0 @@
-class Manifestation
-  attr_accessor :text
-
-  def initialize desired
-    @text = manifestation of: desired[:phrase], from: desired[:genre]
-  end
-
-  private
-
-  def concatenate_lists_in genre
-    unless system("find ./lists/#{genre}/* -exec cat {} > #{genre}.list + 2>&1")
-       puts "There is no lists/#{genre} directory in which to find lists."
-       raise StandardError
-    end
-  end
-
-  def manifestation desire
-    concatenate_lists_in(desire[:from])
-
-    world = Generator.from_file "#{desire[:from]}.list"
-
-    text = world.manifest desire[:of]
-    while text.length > 500
-      text = world.manifest desire[:of]
-    end
-
-    text
-  end
-end
-

data/lib/dunmanifestin/member.rb

@@ -1,18 +0,0 @@
-class Member
-  attr_reader :body, :list
-
-  def initialize(opts={})
-    @list = opts.fetch(:list)
-    @freq = opts.fetch(:frequency, 1)
-    @body = opts.fetch(:body)
-    @universe = opts.fetch(:universe)
-  end
-
-  def to_s
-    body.listerpolate(universe).to_s
-  end
-
-  private
-  
-  attr_reader :universe
-end

data/lib/dunmanifestin/string.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-
-class String
-  def is_name?
-    self[0] == '|'
-  end
-
-  def listerpolate universe
-    body = self
-    
-    while body.match(/\[\w+\]/) do
-      slug = body.match(/\[\w+\]/).to_s
-      phrase = universe.send(slug.gsub('[', '').gsub(']', ''))
-      body = body.sub(slug, phrase)
-    end
-
-    body
-  end
-  
-  alias :original_capitalize :capitalize
-  
-  def capitalize
-    case_mapping = {
-      "ä" => "Ä",
-      "ö" => "Ö",
-    }
-    
-    s = original_capitalize
-    case_mapping.each_pair do |lower, upper|
-      s.gsub!(%r{^#{lower}}, upper)
-    end
-    s
-  end
-  
-  def split_on_newlines_and_strip
-    split(/\s*\n\s*/).reject(&:empty?)
-  end
-end