oulipo 0.1.2 → 0.2.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    oulipo (0.1.1)
+    oulipo (0.2.0)
 
 GEM
   remote: http://rubygems.org/

data/README.md

@@ -40,6 +40,37 @@ sentence = 'Big fjords vex quick waltz nymph.'
 Oulipo.pangram?(sentence) # => true
 ```
 
+## N+7
+
+In N+7 (sometimes known as S+7), each noun in a text is replaced with the noun seven entries after it in a dictionary.
+
+```ruby
+dictionary = Oulipo::WordList.load('big_list_of_nouns.txt')
+
+play = <<-SHAKESPEARE
+
+  What, jealous Oberon! Fairies, skip hence:
+  I have forsworn his bed and company.
+  
+SHAKESPEARE
+
+Oulipo.n_plus(7, play, dictionary)  # => "What, jealous Oberon! Fallacies, skulk hence:
+                                    #     I have forsworn his bedroom and compensation."
+ 
+```
+
+Oulipo includes a handy `WordList` class for reading one-word-per-line dictionary files, but a dictionary can be any object that responds to `index(word)`, `length`, and `[index]`.
+
+```ruby
+dictionary = %w{ iron gild mine gold ore paint cast lily }
+
+king_john = 'To gild refined gold, to paint the lily'
+
+Oulipo.n_plus(1, king_john, dictionary) # => 'To mine refined ore, to cast the iron'
+```
+
+See also: Substitution.
+
 ## Univocalims
 
 A univocalism is a poem written using only one type of vowel.
@@ -84,7 +115,7 @@ poem = <<-WORDS
 
 WORDS
 
-Oulipo.snowball? poem # => true
+Oulipo.snowball?(poem) # => true
 ```
 
 ## Alliteration
@@ -100,7 +131,40 @@ Normal alliteration's a little harsh, so you can give it a threshold, too.
 ```ruby
 phrase = 'quick queens quibble over quails'
 
-Oulipo.allitertivity(phrase) # => 0.8 (4/5 words start with 'q')
+Oulipo.alliterativity(phrase) # => 0.8 (4/5 words start with 'q')
 Oulipo.alleration?(phrase, :threshold => 0.7) # => true 
 Oulipo.alleration?(phrase, :threshold => 0.9) # => false
 ```
+
+## Analysis
+
+Rudimentary analysis can be performed by using Oulipo's `Analysis` class.
+
+```ruby
+line = 'A rose by any other name would smell as sweet'
+
+word_sets = {
+  :nouns => %w{ bear name rose },
+  :adjectives => %w{ sweet }
+}
+
+analysis = Oulipo::Analysis.new(line, word_sets)
+
+analysis.identified(:nouns)      # => ['rose', 'name']
+analysis.identified(:adjectives) # => ['sweet']
+```
+
+## Substitution
+
+Substitution can be performed on an analysis.
+
+Carrying on from the example above:
+
+```ruby
+substitutor = Oulipo::Substitutor.new(analysis)
+substitutor.replace(:nouns).increment(1) # => "A bear by any other rose would smell as sweet"
+```
+
+---
+
+- Pete Nicholls ([@Aupajo](http://twitter.com/Aupajo))

data/lib/oulipo/analysis.rb

@@ -0,0 +1,60 @@
+module Oulipo
+  class Analysis
+    include Enumerable
+    
+    attr_reader :original, :deconstruction, :word_lists
+  
+    def initialize(text, options = {})
+      @word_lists = options
+      @original = text
+      deconstruct!
+    end
+    
+    def identified(type = nil)
+      result = identified_tuples
+      result.select! { |tuple| tuple.last == type } if type
+      result.map(&:first)
+    end
+    
+    private
+    
+    def is_tuple?(object)
+      object.is_a?(Array)
+    end
+    
+    def is_plain?(object)
+      object.is_a?(String)
+    end
+    
+    def identified_tuples
+      deconstruction.select { |segment| is_tuple?(segment) }
+    end
+    
+    def identify(wordish)
+      return wordish if wordish.strip.empty?
+      
+      word_lists.each do |type, list|
+        return [wordish, type] if list.index(wordish.downcase)
+      end
+      
+      wordish
+    end
+    
+    def deconstruct!
+      chunks = original.split(/\b/)
+      
+      @deconstruction = []
+      
+      chunks.each do |wordish|
+        analysis = identify(wordish)
+        
+        if is_plain?(analysis) and is_plain?(deconstruction.last)
+          deconstruction.last << analysis
+        else
+          deconstruction << analysis
+        end
+      end
+    end
+    
+  end
+end

data/lib/oulipo/substitutor.rb

@@ -0,0 +1,51 @@
+module Oulipo
+  class Substitutor
+    
+    def initialize(analysis)
+      @analysis = analysis
+    end
+    
+    def replace(type)
+      @type = type
+      self
+    end
+    
+    def increment(num)
+      raise 'Increment must be called in conjunction with replace' if !@type
+      
+      result = ''
+      
+      @analysis.deconstruction.each do |segment|
+        if segment.is_a?(Array) # tuple found
+          if segment.last == @type # ready to replace
+            result << find_successor(segment.first, num)
+          else
+            result << segment.first
+          end
+        else
+          result << segment
+        end
+      end
+      
+      result
+    end
+    
+    private
+    
+    def word_list
+      @analysis.word_lists[@type]
+    end
+    
+    def find_successor(word, num)
+      # Find the current index and the limit
+      current_index = word_list.index(word.downcase)
+      limit = word_list.length
+      
+      # Calculate the successor's index, wrapping if we need to
+      successor = (current_index + num) % limit
+      
+      word_list[successor]
+    end
+    
+  end
+end

data/lib/oulipo/word_list.rb

@@ -0,0 +1,34 @@
+module Oulipo
+  class WordList
+    def initialize
+      @words = []
+    end
+    
+    def self.load(file)
+      dict = self.new
+      file = File.open(file) if file.is_a?(String)
+      
+      file.each_line do |word|
+        dict.push(word.strip)
+      end
+      
+      dict
+    end
+    
+    def index(word)
+      @words.index(word)
+    end
+    
+    def length
+      @words.length
+    end
+    
+    def [](index)
+      @words[index]
+    end
+    
+    def push(word)
+      @words.push(word)
+    end
+  end
+end

data/lib/oulipo.rb

@@ -1,4 +1,8 @@
-class Oulipo
+require 'oulipo/word_list'
+require 'oulipo/analysis'
+require 'oulipo/substitutor'
+
+module Oulipo
   ALPHABET = 'a'..'z'
   VOWELS = %w{ a e i o u }
   
@@ -66,4 +70,10 @@ class Oulipo
     most_used_count = leading_letter_counts.max_by { |kv| kv.last }.pop
     most_used_count.to_f / words.length
   end
+  
+  def self.n_plus(places, text, word_list)
+    analysis = Analysis.new(text, :nouns => word_list)
+    substitutor = Substitutor.new(analysis)
+    substitutor.replace(:nouns).increment(places)
+  end
 end

data/oulipo.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path('../lib', __FILE__)
 
 Gem::Specification.new do |s|
   s.name              = "oulipo"
-  s.version           = "0.1.2"
+  s.version           = "0.2.0"
   s.date              = Time.now.strftime('%Y-%m-%d')
   s.homepage          = "http://github.com/Aupajo/oulipo"
   s.email             = "pete@metanation.com"

data/spec/analysis_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Oulipo::Analysis do
+  include Oulipo
+  
+  let(:folksong) { "O'er the moor and among the heather" }
+  
+  let(:word_lists) { { :nouns => %w{ moor heather },
+                       :prepositions => %w{ among } } }
+  
+  let(:analysis) { Analysis.new(folksong, word_lists) }
+  
+  it "can identify words" do
+    analysis.identified.sort.should == %w{ among heather moor }
+    analysis.identified(:nouns).should == %w{ moor heather }
+    analysis.identified(:prepositions).should == %w{ among }
+  end
+  
+  it "can return the original string" do
+    analysis.original.should == "O'er the moor and among the heather"
+  end
+  
+  it "can return the raw deconstruction" do
+    deconstruction = ["O'er the ", ['moor', :nouns], ' and ', ['among', :prepositions], ' the ', ['heather', :nouns]]
+    analysis.deconstruction.should == deconstruction
+  end
+  
+  it "can return the word lists it's using" do
+    analysis.word_lists.should == word_lists
+  end
+  
+end

data/spec/fixtures/word_list.txt

@@ -0,0 +1,3 @@
+apple
+car
+dog

data/spec/substitution_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe "substitution" do
+  
+  def analysis_with(phrase, options)
+    Oulipo::Analysis.new(phrase, options)
+  end
+  
+  def substitutor_with(*args)
+    Oulipo::Substitutor.new analysis_with(*args)
+  end
+  
+  let(:performer) { Oulipo }
+  
+  let(:phrase) { 'The bear ate the badger' }
+  let(:noun_list) { %w{ badger bat bear } }
+  let(:substitutor) { substitutor_with(phrase, :nouns => noun_list) }
+  
+  it "substitutes types" do
+    substitutor.replace(:nouns).increment(1).should == 'The badger ate the bat'
+    substitutor.replace(:nouns).increment(2).should == 'The bat ate the bear'
+    substitutor.replace(:nouns).increment(6).should == 'The bear ate the badger'
+  end
+  
+  it "raises an error if increment is called before replace" do
+    lambda { substitutor.increment(3) }.should raise_error
+  end
+  
+  it "can be accessed from Oulipo with n_plus" do
+    performer.n_plus(1, phrase, noun_list).should == 'The badger ate the bat'
+    performer.n_plus(2, phrase, noun_list).should == 'The bat ate the bear'
+    performer.n_plus(6, phrase, noun_list).should == 'The bear ate the badger'
+  end
+  
+  it "handles unused nouns" do
+    nouns = %w{ badger bear bat ball balustrade }
+    substitutor = substitutor_with(phrase, :nouns => nouns)
+    substitutor.replace(:nouns).increment(4).should == 'The badger ate the balustrade'
+  end
+  
+  it "matches case" do
+    substitutor = substitutor_with('The BEAR ate the BadgeR', :nouns => noun_list)
+    substitutor.replace(:nouns).increment(1).should == 'The badger ate the bat'
+  end
+  
+end

data/spec/word_list_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Oulipo::WordList do
+  
+  let(:word_list) { Oulipo::WordList.new }
+  
+  it "acts like an array" do
+    word_list.length.should == 0
+    word_list.index('apple').should be_nil
+    word_list[0].should == nil
+    
+    word_list.push('apple')
+    
+    word_list.length.should == 1
+    word_list.index('apple').should == 0
+    word_list[0].should == 'apple'
+  end
+  
+  it "loads from a file name" do
+    list = Oulipo::WordList.load(File.dirname(__FILE__) + '/fixtures/word_list.txt')
+    list.length.should == 3
+    list.index('car').should == 1
+    list[2].should == 'dog'
+  end
+  
+  it "loads from a file" do
+    file = File.open(File.dirname(__FILE__) + '/fixtures/word_list.txt')
+    list = Oulipo::WordList.load(file)
+    list.length.should == 3
+    list.index('car').should == 1
+    list[2].should == 'dog'
+  end
+  
+end

metadata

@@ -2,7 +2,7 @@
 name: oulipo
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - Pete Nicholls
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-28 00:00:00 +12:00
+date: 2011-07-29 00:00:00 +12:00
 default_executable: 
 dependencies: []
 
@@ -29,13 +29,20 @@ files:
 - README.md
 - Rakefile
 - lib/oulipo.rb
+- lib/oulipo/analysis.rb
+- lib/oulipo/substitutor.rb
+- lib/oulipo/word_list.rb
 - oulipo.gemspec
 - spec/alliteration_spec.rb
+- spec/analysis_spec.rb
 - spec/chaterisms_spec.rb
+- spec/fixtures/word_list.txt
 - spec/lipograms_spec.rb
 - spec/palindromes_spec.rb
 - spec/spec_helper.rb
+- spec/substitution_spec.rb
 - spec/univocalisms_spec.rb
+- spec/word_list_spec.rb
 has_rdoc: true
 homepage: http://github.com/Aupajo/oulipo
 licenses: []
@@ -66,8 +73,12 @@ specification_version: 3
 summary: Constrained writing with Ruby.
 test_files: 
 - spec/alliteration_spec.rb
+- spec/analysis_spec.rb
 - spec/chaterisms_spec.rb
+- spec/fixtures/word_list.txt
 - spec/lipograms_spec.rb
 - spec/palindromes_spec.rb
 - spec/spec_helper.rb
+- spec/substitution_spec.rb
 - spec/univocalisms_spec.rb
+- spec/word_list_spec.rb