oulipo 0.2.0 → 0.3.1

data/Gemfile.lock

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

data/README.md

@@ -8,7 +8,7 @@ It's still young, and very much liable to change.
 
 The real [Oulipo](http://en.wikipedia.org/wiki/Oulipo) is a gathering of writers and mathmeticians who seek to create works using constrained writing techniques.
 
-Install with `gem install oulipo`.
+Install with `gem install oulipo` and `require 'oulipo'` as needed.
 
 ## Lipograms and Pangrams
 
@@ -40,37 +40,6 @@ 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.
@@ -132,8 +101,56 @@ Normal alliteration's a little harsh, so you can give it a threshold, too.
 phrase = 'quick queens quibble over quails'
 
 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
+Oulipo.alliteration?(phrase, :threshold => 0.7) # => true 
+Oulipo.alliteration?(phrase, :threshold => 0.9) # => false
+```
+
+## 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'
+```
+
+## Extending String
+
+You can optionally extend `String`, if you need to.
+
+```ruby
+require 'oulipo/string_em_up'
+
+"Sator arepo tenet opera rotas".palindrome? # => true
+"Waltz, bad nymph, for quick jigs vex!".pangram? # => true
+'To gild refined gold'.n_plus(7, nouns) # ... as above
+```
+
+If you'd like to use the neat short-hand, but don't want to touch `String`, you might want to use an `EnhancedString`.
+
+```ruby
+palindrome = Oulipo::EnhancedString.new("Sator arepo tenet opera rotas")
+palindrome.lipogram? # => true
 ```
 
 ## Analysis
@@ -152,6 +169,8 @@ analysis = Oulipo::Analysis.new(line, word_sets)
 
 analysis.identified(:nouns)      # => ['rose', 'name']
 analysis.identified(:adjectives) # => ['sweet']
+
+analysis.deconstruction # => ["A ", ["rose", :nouns], " by any other ", ["name", :nouns], " would smell as ", ["sweet", :adjectives]]
 ```
 
 ## Substitution
@@ -167,4 +186,4 @@ substitutor.replace(:nouns).increment(1) # => "A bear by any other rose would sm
 
 ---
 
-- Pete Nicholls ([@Aupajo](http://twitter.com/Aupajo))
+Pete Nicholls ([@Aupajo](http://twitter.com/Aupajo))

data/lib/oulipo/enhanced_string.rb

@@ -0,0 +1,5 @@
+module Oulipo
+  class EnhancedString < String
+    include Oulipo::StringExtensions
+  end
+end

data/lib/oulipo/string_em_up.rb

@@ -0,0 +1,3 @@
+class String
+  include Oulipo::StringExtensions
+end

data/lib/oulipo/string_extensions.rb

@@ -0,0 +1,86 @@
+module Oulipo
+  module StringExtensions
+    ALPHABET = 'a'..'z'
+    VOWELS = %w{ a e i o u }
+    
+    # Whether the string uses alliteration or not.
+    # Accepts a :threshold option for determining whether the string
+    # uses sufficient alliteration (see #aliterativity)
+    def alliteration?(options = {})
+      threshold = options.delete(:threshold) || 1
+      self.alliterativity >= threshold
+    end
+    
+    # A score between 0 and 1 representing the level of alliteration
+    def alliterativity
+      words = self.downcase.gsub(/[^a-z\s]/, '').split
+      leading_letters = words.map(&:chr)
+      
+      # { 'a' => 3, 'b' => 1, ... }
+      leading_letter_counts = leading_letters.inject({}) do |result, letter|
+        result[letter] ||= 0
+        result[letter] += 1
+        result
+      end
+      
+      most_used_count = leading_letter_counts.max_by { |kv| kv.last }.pop
+      most_used_count.to_f / words.length
+    end
+    
+    # The same letters backwards as forwards
+    def palindrome?
+      letter_sequence = self.downcase.gsub(/[^a-z]/, '')
+      letter_sequence.reverse == letter_sequence
+    end
+    
+    # Replace the words in the word list with the word n places after it
+    def n_plus(places, word_list)
+      analysis = Analysis.new(self, :nouns => word_list)
+      substitutor = Substitutor.new(analysis)
+      substitutor.replace(:nouns).increment(places)
+    end
+    
+    # Returns true if each word is one letter larger than the previous
+    def snowball?
+      words = self.split
+      self.chaterism? && words.first.length < words.last.length
+    end
+    
+    # Returns true if only one vowel is used
+    def univocalism?
+      present_letters = self.downcase.split('').uniq
+      (VOWELS - present_letters).length == 4
+    end
+    
+    # Returns true if the string is a sequence of words in each of which is one letter larger than the 
+    # previous, or each word in the sequence is one letter less than the previous
+    def chaterism?
+      words = self.gsub(/[^a-z\s]/i, '').split
+
+      # Find the direction we're traveling
+      flen, llen = words.first.length, words.last.length
+      direction = flen > llen ? :downto : :upto
+      
+      # Compare the pattern of word lengths against a range-turned-array of expected word lengths
+      words.map(&:length) == flen.send(direction, llen).to_a
+    end
+    
+    # Returns an array of letters that are absent
+    def absent_letters
+      present_letters = self.downcase.split('').uniq
+      missing_letters = ALPHABET.to_a - present_letters
+      missing_letters.empty? ? nil : missing_letters
+    end
+    
+    # Returns true if all letters of the alphabet are used
+    def pangram?
+      self.absent_letters.nil?
+    end
+    
+    # Returns true if not all of the letters of the alphabet are used
+    def lipogram?
+      !self.pangram?
+    end
+    
+  end
+end

data/lib/oulipo.rb

@@ -1,79 +1,21 @@
 require 'oulipo/word_list'
+require 'oulipo/string_extensions'
+require 'oulipo/enhanced_string'
 require 'oulipo/analysis'
 require 'oulipo/substitutor'
 
 module Oulipo
-  ALPHABET = 'a'..'z'
-  VOWELS = %w{ a e i o u }
   
-  def self.absent_letters(work)
-    present_letters = work.downcase.split('').uniq
-    missing_letters = ALPHABET.to_a - present_letters
-    missing_letters.empty? ? nil : missing_letters
-  end
-  
-  # A pangram uses all letters
-  def self.pangram?(work)
-    self.absent_letters(work).nil?
-  end
-  
-  # A lipogram has missing letters
-  def self.lipogram?(work)
-    !self.pangram?(work)
-  end
-  
-  # In a chaterism, each successive word is larger than the last or vice versa
-  def self.chaterism?(poem)
-    # Discard the punctuation, split into words
-    words = poem.gsub(/[^a-z\s]/i, '').split
-    
-    # Find the direction we're traveling
-    flen, llen = words.first.length, words.last.length
-    direction = flen > llen ? :downto : :upto
-    
-    # "The tree sings".map(&:length) # => [3, 4, 5] 
-    # [3, 4, 5] == 3.upto(5).to_a # => true
-    words.map(&:length) == flen.send(direction, llen).to_a
-  end
-  
-  def self.univocalism?(poem)
-    present_letters = poem.downcase.split('').uniq
-    (VOWELS - present_letters).length == 4
-  end
-  
-  def self.snowball?(poem)
-    words = poem.split
-    self.chaterism?(poem) && words.first.length < words.last.length
-  end
-  
-  def self.palindrome?(phrase)
-    sequence = phrase.downcase.gsub(/[^a-z]/, '')
-    sequence.reverse == sequence
-  end
-  
-  def self.alliteration?(phrase, options = {})
-    threshold = options.delete(:threshold) || 1
-    self.alliterativity(phrase) >= threshold
-  end
-  
-  # Calculate an alliteration score
-  def self.alliterativity(phrase)
-    words = phrase.downcase.gsub(/[^a-z\s]/, '').split
-    leading_letters = words.map(&:chr)
-    
-    leading_letter_counts = leading_letters.inject({}) do |result, letter|
-      result[letter] ||= 0
-      result[letter] += 1
-      result
-    end
-    
-    most_used_count = leading_letter_counts.max_by { |kv| kv.last }.pop
-    most_used_count.to_f / words.length
+  [:absent_letters, :pangram?, :lipogram?, :chaterism?,
+   :univocalism?, :snowball?, :palindrome?, :alliteration?,
+   :alliterativity].each do |method|
+      define_singleton_method(method.to_sym) do |*args|
+        EnhancedString.new(args.shift).send(method.to_sym, *args)
+      end
   end
   
+  # Replace the word nth places ahead in the word_list
   def self.n_plus(places, text, word_list)
-    analysis = Analysis.new(text, :nouns => word_list)
-    substitutor = Substitutor.new(analysis)
-    substitutor.replace(:nouns).increment(places)
+    EnhancedString.new(text).n_plus(places, word_list)
   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.2.0"
+  s.version           = "0.3.1"
   s.date              = Time.now.strftime('%Y-%m-%d')
   s.homepage          = "http://github.com/Aupajo/oulipo"
   s.email             = "pete@metanation.com"

data/spec/alliteration_spec.rb

@@ -1,26 +1,28 @@
 require 'spec_helper'
+require 'oulipo/string_em_up'
 
 describe "alliteration" do
   
-  let(:performer) { Oulipo }
-  
   let(:pure_alliteration) { 'spec step succeeds speedily' }
   let(:mostly_alliterative) { 'quick queens quibble over quails' }
   
   it "detects pure alliteration" do
-    performer.alliteration?(pure_alliteration).should == true
+    pure_alliteration.should be_alliteration
   end
-  
+
   it "tells us the alliterativity of a phrase" do
-    performer.alliterativity(pure_alliteration).should   == 1.0
-    performer.alliterativity(mostly_alliterative).should == 0.8
+    pure_alliteration.alliterativity.should   == 1.0
+    mostly_alliterative.alliterativity.should == 0.8
   end
-  
+
   it "detects alliteration with a threshold" do
-    performer.alliteration?(mostly_alliterative).should == false
-    performer.alliteration?(mostly_alliterative, :threshold => 0.7).should == true
-    performer.alliteration?(mostly_alliterative, :threshold => 0.8).should == true
-    performer.alliteration?(mostly_alliterative, :threshold => 0.9).should == false
+    mostly_alliterative.should_not be_alliteration
+    mostly_alliterative.should be_alliteration(:threshold => 0.7)
+    mostly_alliterative.should be_alliteration(:threshold => 0.8)
+    mostly_alliterative.should_not be_alliteration(:threshold => 0.9)
   end
   
+  it "is accessible via Oulipo" do
+    Oulipo.should forward_to_enhanced_string(:alliterativity, :alliteration?)
+  end
 end

data/spec/analysis_spec.rb

@@ -1,14 +1,13 @@
 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) }
+  let(:analysis) { Oulipo::Analysis.new(folksong, word_lists) }
   
   it "can identify words" do
     analysis.identified.sort.should == %w{ among heather moor }

data/spec/chaterisms_spec.rb

@@ -1,10 +1,8 @@
 require 'spec_helper'
+require 'oulipo/string_em_up'
 
 describe "chaterisms" do
   
-  # For easy switching
-  let(:performer) { Oulipo }
-  
   let(:snowball_poem) do
     <<-POEM
       The
@@ -33,15 +31,18 @@ describe "chaterisms" do
   }
   
   it "can detect both diminishing and growing chaterisms" do
-    performer.chaterism?(snowball_poem).should == true
-    performer.chaterism?(diminishing_poem).should == true
-    performer.chaterism?(regular_poem).should == false
+    snowball_poem.should be_chaterism
+    diminishing_poem.should be_chaterism
+    regular_poem.should_not be_chaterism
   end
   
   it "detects a snowball poem" do
-    performer.snowball?(snowball_poem).should == true
-    performer.snowball?(diminishing_poem).should == false
-    performer.snowball?(regular_poem).should == false
+    snowball_poem.should be_snowball
+    diminishing_poem.should_not be_snowball
+    regular_poem.should_not be_snowball
   end
   
+  it "is accessible via Oulipo" do
+    Oulipo.should forward_to_enhanced_string(:chaterism?, :snowball?)
+  end
 end

data/spec/lipograms_spec.rb

@@ -1,24 +1,26 @@
 require 'spec_helper'
+require 'oulipo/string_em_up'
 
 describe "lipograms and pangrams" do
   
-  # Easy to switch class, if refactored
-  let(:performer) { Oulipo }
-  
   let(:pangram) { 'The quick brown fox jumps over a lazy god' }
   let(:lipogram) { 'The quick grey fox jumps over lazy gods' }
   
   it "shows absent letters" do
-    performer.absent_letters(pangram).should == nil
-    performer.absent_letters(lipogram).should == %w{ b n w }
+    pangram.absent_letters.should be_nil
+    lipogram.absent_letters.should == %w{ b n w }
   end
   
   it "can tell a pangram from a lipogram" do
-    performer.lipogram?(lipogram).should == true
-    performer.lipogram?(pangram).should == false
+    lipogram.should be_lipogram
+    pangram.should_not be_lipogram
     
-    performer.pangram?(pangram).should == true
-    performer.pangram?(lipogram).should == false
+    lipogram.should_not be_pangram
+    pangram.should be_pangram
+  end
+  
+  it "is accessible via Oulipo" do
+    Oulipo.should forward_to_enhanced_string(:lipogram?, :pangram?)
   end
   
 end

data/spec/palindromes_spec.rb

@@ -2,11 +2,13 @@ require 'spec_helper'
 
 describe "palindromes" do
   
-  let(:performer) { Oulipo }
-  
   it "detects palindromes" do
-    performer.palindrome?('Mr. Owl ate my metal worm').should == true
-    performer.palindrome?('Carelessness is a dish best served drunk').should == false
+    'Mr. Owl ate my metal worm'.should be_palindrome
+    'Carelessness is a dish best served drunk'.should_not be_palindrome
+  end
+  
+  it "is accessible via Oulipo" do
+    Oulipo.should forward_to_enhanced_string(:palindrome?)
   end
   
 end

data/spec/spec_helper.rb

@@ -2,4 +2,16 @@ require 'bundler'
 Bundler.setup(:default, :test)
 
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'oulipo'
+require 'oulipo'
+
+RSpec::Matchers.define :forward_to_enhanced_string do |*forwarded_methods|
+  match do |oulipo|
+    stubs = forwarded_methods.inject({}) { |stubs, method| stubs.merge(method => :forwarded) }
+    enhanced_string = mock(:enhanced_string, stubs)
+    Oulipo::EnhancedString.should_receive(:new).with('a phrase').at_least(:once).and_return(enhanced_string)
+    
+    forwarded_methods.each do |method|
+      oulipo.send(method, 'a phrase').should == :forwarded
+    end
+  end
+end

data/spec/substitution_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'oulipo/string_em_up'
 
 describe "substitution" do
   
@@ -10,8 +11,6 @@ describe "substitution" do
     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) }
@@ -25,11 +24,17 @@ describe "substitution" do
   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'
+    Oulipo.n_plus(1, phrase, noun_list).should == 'The badger ate the bat'
+    Oulipo.n_plus(2, phrase, noun_list).should == 'The bat ate the bear'
+    Oulipo.n_plus(6, phrase, noun_list).should == 'The bear ate the badger'
+  end
+
+  it "can be accessed from a string with n_plus" do
+    phrase.n_plus(1, noun_list).should == 'The badger ate the bat'
+    phrase.n_plus(2, noun_list).should == 'The bat ate the bear'
+    phrase.n_plus(6, noun_list).should == 'The bear ate the badger'
   end
   
   it "handles unused nouns" do

data/spec/univocalisms_spec.rb

@@ -1,9 +1,8 @@
 require 'spec_helper'
+require 'oulipo/string_em_up'
 
 describe "univocalisms" do
   
-  let(:performer) { Oulipo }
-  
   let(:univocalism) {
     <<-POEM
       No cool monsoons blow soft on Oxford dons,
@@ -23,8 +22,11 @@ describe "univocalisms" do
   }
   
   it "detects a univocalism" do
-    performer.univocalism?(univocalism).should == true
-    performer.univocalism?(regular_poem).should == false
+    univocalism.should be_univocalism
+    regular_poem.should_not be_univocalism
   end
   
+  it "is accessible via Oulipo" do
+    Oulipo.should forward_to_enhanced_string(:univocalism?)
+  end
 end

metadata

@@ -1,28 +1,22 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: oulipo
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.3.1
   prerelease: 
-  version: 0.2.0
 platform: ruby
-authors: 
+authors:
 - Pete Nicholls
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-07-29 00:00:00 +12:00
-default_executable: 
+date: 2011-08-01 00:00:00.000000000 Z
 dependencies: []
-
 description: Oulipo gives you tools to write constrained stories and poems with Ruby.
 email: pete@metanation.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -30,6 +24,9 @@ files:
 - Rakefile
 - lib/oulipo.rb
 - lib/oulipo/analysis.rb
+- lib/oulipo/enhanced_string.rb
+- lib/oulipo/string_em_up.rb
+- lib/oulipo/string_extensions.rb
 - lib/oulipo/substitutor.rb
 - lib/oulipo/word_list.rb
 - oulipo.gemspec
@@ -43,35 +40,31 @@ files:
 - spec/substitution_spec.rb
 - spec/univocalisms_spec.rb
 - spec/word_list_spec.rb
-has_rdoc: true
 homepage: http://github.com/Aupajo/oulipo
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Constrained writing with Ruby.
-test_files: 
+test_files:
 - spec/alliteration_spec.rb
 - spec/analysis_spec.rb
 - spec/chaterisms_spec.rb