dunmanifestin 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZGY3OWM3NzkwOWIwZmNjYjllYjlkMWUzMzIwOWE5ZmU2YzY5MDhkNA==
+  data.tar.gz: !binary |-
+    MmZhYjIwYWYyOWU3ZjkzYWFmMGMyN2U1YzE3NDY4NmE2N2YwZGQzYQ==
+SHA512:
+  metadata.gz: !binary |-
+    MDdjOGY5ODNiOTMyYzViNmIwNjUwN2RjNjViOTk4ZGQxYWEyMmQ2ZmM4NmY4
+    YjVlYmI0ZDRmNGRjNjBlYTdmNzU3N2Q0MmVhY2ViZmQyZjVjMDA0MmNkZDgx
+    MzI3MTAyODA4NWIwMTEzNDIwYmU4MzY1Zjg5NzFiYTJlNzIyYmY=
+  data.tar.gz: !binary |-
+    M2U3MWZmNjUwM2FhZWNlZjg1M2Y1M2VlZDA0MTdkNDhmMDRlNjQzNDAxM2Mx
+    N2EzNjg4ZTliOWEyMDQ3YzNjMTc1OWRjMDk4Yzk3NzA4NmZlNmFiNzhjMWMw
+    ZjI5MDJmNGM4YjU0OTc3MjEwZTc3M2VjMzA3ZDFkMDAzNjcxYWM=

data/bin/dunmanifestin

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'dunmanifestin'
+
+user_demands = Trollop::options do
+  opt :debug, "Display errors and logging", short: '-d'
+  opt :interactive, "Use an interactive command prompt", short: '-i'
+  opt :count, "Specify how many lines of output to generate at once", type: :integer, short: '-n'
+  opt :copy, "Copies manifestation into your clipboard", short: '-c'
+  opt :genre, "Specify a genre, e.g. '-g scifi'", type: :string, short: '-g', default: 'default'
+  opt :phrase, "Specify a phrase or list, e.g. 'The [animal] sat on the [article]' or '[weapon]'", type: :string, short: '-p', default: '[root]'
+  opt :chomp, "remove the trailing newline from the output", short: '-h'
+end
+
+def get_from_prompt
+  print "dunmanifestin > "
+  gets.chomp
+end
+
+begin
+  root_phrase_class = Class.new(Phrase) { list user_demands[:phrase] }
+  ListLoader.new(user_demands[:genre]).load
+
+  if user_demands[:interactive]
+    print "---------------------------------------------------------------------\n"+
+          "Type 'quit' to exit the prompt. Press return to generate more output.\n"+
+          "---------------------------------------------------------------------\n\n"
+  end
+
+  fulltext = ""
+
+  while true
+    (user_demands[:count] || 1).times do
+      text = root_phrase_class.new.inspect
+      fulltext += "\n#{text}"
+      text += "\n" unless user_demands[:chomp]
+      print text
+    end
+
+    `echo #{fulltext.inspect} | pbcopy $1` if user_demands[:copy]
+
+    break if !user_demands[:interactive] || get_from_prompt == 'quit'
+  end
+
+rescue => e
+  raise e if user_demands[:debug]
+ensure
+  `rm #{user_demands[:genre]}.list 2>&1` unless user_demands[:debug]
+end

data/lib/dunmanifestin.rb

@@ -0,0 +1,11 @@
+$:.unshift File.dirname(__FILE__) # For dev/use when no gem is installed
+
+require 'trollop'
+require 'dunmanifestin/member.rb'
+require 'dunmanifestin/list.rb'
+require 'dunmanifestin/generator.rb'
+require 'dunmanifestin/string.rb'
+require 'dunmanifestin/custom_inflections.rb'
+require 'dunmanifestin/phrase.rb'
+require 'dunmanifestin/manifestation.rb'
+require 'dunmanifestin/list_loader.rb'

data/lib/dunmanifestin/custom_inflections.rb

@@ -0,0 +1,5 @@
+require 'active_support/inflector'
+
+ActiveSupport::Inflector.inflections do |inflect| 
+  inflect.irregular 'human', 'humans' 
+end

data/lib/dunmanifestin/generator.rb

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,30 @@
+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
+  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

@@ -0,0 +1,46 @@
+class ListLoader
+  def initialize genre = 'default'
+    @genre = genre
+  end
+
+  def load genre=@genre
+    dir_of_this_file = File.dirname(__FILE__)
+    default_list_dir = File.join(*%W(#{dir_of_this_file} .. .. lists default ** *))
+    Dir[default_list_dir].each { |list_path| create_list_from(list_path) }
+
+    if genre != 'default'
+      Dir[File.join(*%W(#{dir_of_this_file} .. lists #{genre} ** *))].each { |list_path| create_list_from(list_path) }
+    end
+  end
+
+  private
+
+  def create_list_from path
+    newlines_before_a_pipe = /\n(?=\|)/
+    everything_up_to_the_first_newline_if_first_character_is_a_pipe = /^\|(.*?)\n/
+    everything_after_the_last_slash = /\/.+$/
+
+    lists = File.open(path).read.split(newlines_before_a_pipe)
+    lists.each_with_index do |_list, i|
+      list_name = _list.match(everything_up_to_the_first_newline_if_first_character_is_a_pipe)[1].to_s
+
+      if list_name.empty?
+        list_name = path.match(everything_after_the_last_slash).to_s
+      else
+        _list.gsub!(everything_up_to_the_first_newline_if_first_character_is_a_pipe, '')
+      end
+
+      phrase_class_name = list_name.underscore.camelize
+      begin
+        qlass = "Phrase::#{phrase_class_name}".constantize
+      rescue NameError
+        qlass = Class.new(Phrase)
+        Phrase.const_set phrase_class_name, qlass
+      end
+
+      qlass.list(_list)
+    end
+  end
+end
+
+

data/lib/dunmanifestin/manifestation.rb

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,18 @@
+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/phrase.rb

@@ -0,0 +1,198 @@
+require 'active_support/inflector'
+
+class Phrase
+  def self.list new_list = nil
+    return @list unless new_list
+    
+    if new_list.is_a? String
+      new_list = new_list.split_on_newlines_and_strip
+    end
+    
+    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? }
+    
+    @list = new_list
+  end
+  
+  def initialize dsl_string = self.class.list.sample
+    compile parse dsl_string
+  end
+  
+  def compile parsed_dsl
+    template = parsed_dsl[:template]
+    
+    @variable_classes = []
+    @inflection_delegates = {
+      :plural => [],
+      :possessive => [],
+      :article => [],
+      :capitalize => [],
+    }
+    
+    inflections = []
+    
+    parsed_dsl[:variables].each_with_index do |variable, i|
+      rough_var_class = variable[:rough_variable_class]
+      
+      variable[:inflections_to_delegate].each do |inflection|
+        @inflection_delegates[inflection.to_sym] << i
+      end
+      
+      inflections[i] = []
+      
+      variable[:inflections_to_apply].each do |inflection|
+        inflections[i] << inflection.to_sym
+      end
+      
+      begin
+        @variable_classes << "Phrase::#{rough_var_class.camelize}".constantize
+      rescue NameError
+        @variable_classes << eval(%Q|Class.new(Phrase) do
+          def initialize
+            @to_s_proc = -> { "{#{rough_var_class} ??}" }
+          end
+        end|)
+      end
+    end
+    
+    @to_s_proc = -> {
+      self.variables.each_with_index do |variable, i|
+        inflections[i].each do |inflection|
+          variable.send "#{inflection}!"
+        end
+      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
+    
+    hash = {:variables => [], :template => template}
+    
+    variables.each_with_index do |variable, i|
+      components = variable.split(/\b/)
+      rough_var_class = components.shift
+      inflections_to_delegate = []
+      inflections_to_apply = []
+      
+      components.each_with_index do |v, k|
+        inflections_to_delegate << v if components[k-1] == '#'
+        inflections_to_apply << v if components[k-1] == '.'
+      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 plural!
+    @plural = true
+    
+    @inflection_delegates[:plural].each do |delegate|
+      variables[delegate].plural!
+    end
+    self
+  end
+  
+  def article!
+    @article = true
+    
+    @inflection_delegates[:article].each do |delegate|
+      variables[delegate].article!
+    end
+    self
+  end
+  
+  def possessive!
+    @possessive = true
+    
+    @inflection_delegates[:possessive].each do |delegate|
+      variables[delegate].possessive!
+    end
+    self
+  end
+  
+  def capitalize!
+    @capitalize = true
+    
+    @inflection_delegates[:capitalize].each do |delegate|
+      variables[delegate].capitalize!
+    end
+    self
+  end
+
+  def to_s
+    render_inflections @to_s_proc.call
+  end
+  
+  def render_inflections string
+    if plural?
+      string = string.pluralize if @inflection_delegates[:plural].empty?
+      if possessive? && @inflection_delegates[:possessive].empty?
+        if string =~ /s$/
+          string = "#{string}'"
+        else
+          string = "#{string}'s"
+        end
+      end
+    else
+      #singular
+      if article? && @inflection_delegates[:article].empty?
+        if string =~ /^[aeiou]/i
+          string = "an #{string}"
+        else
+          string = "a #{string}"
+        end
+      end
+      if possessive? && @inflection_delegates[:possessive].empty?
+        string = "#{string}'s"
+      end
+    end
+    
+    string = string.capitalize if capitalize?
+    
+    string
+  end
+end