elliottcable-stringray 2 → 3

data/.manifest

@@ -1,5 +1,8 @@
 lib/stringray.rb
-Rakefile
-README.mkdn
+lib/stringray/core_ext.rb
+lib/stringray/core_ext/kernel.rb
+lib/stringray/core_ext/spec/rake/verify_rcov.rb
 spec/stringray_spec.rb
+README.markdown
+Rakefile.rb
 .manifest

data/README.markdown

@@ -0,0 +1,59 @@
+StringRay
+=========
+
+**StringRay** exposes a powerful method to split a `String` into an `Array` of
+words, and further allows you to include `Enumerable`, thus exposing many of the most useful `Array` methods on your `String`s.
+
+Links
+-----
+
+* [source (GitHub)](http://github.com/elliottcable/stringray "GitHub source repository")
+* [wiki (Google Code)](http://code.google.com/p/stringray/w/list "Google Code wiki")
+* [issues (Google Code)](http://code.google.com/p/stringray/issues "Google Code issues")
+* [Gitorious mirror](http://gitorious.org/projects/stringray "Gitorious source repository")
+* [RubyForge mirror](http://rubyforge.org/projects/stringray/ "RubyForge project")
+* [repo.or.cz mirror](http://repo.or.cz/w/stringray.git "repo.or.cz source repository")
+
+
+Usage
+-----
+    
+    class String; include StringRay; end
+    
+    "Oi! I'm a string, do something fun with me!".enumerate do |word|
+      p word
+    end
+    
+    class String; make_enumerable!; end
+    "Who, what, when, where, why? The questions these are.".map do |word|
+      word << word[0].chr
+    end
+    
+Getting
+-------
+
+The authoritative source for this project is available at
+<http://github.com/elliottcable/stringray>. You can clone your own copy with
+the following command:
+
+    git clone git://github.com/elliottcable/stringray.git
+
+If you want to make changes to the codebase, you need to fork your own GitHub
+repository for said changes. Send a pullrequest to [elliottcable](http://github.com/elliottcable "elliottcable on GitHub")
+when you've got something ready for the master branch that you think should be
+merged.
+
+Requirements
+------------
+
+To use StringRay, you need... nothing!
+
+Contributing
+------------
+
+To develop and contribute to StringRay, you need...
+
+* `gem install rake`
+* `gem install rspec`
+* `gem install rcov`
+* `gem install echoe`

data/{Rakefile → Rakefile.rb}

@@ -2,48 +2,42 @@
 require 'stringray'
 require 'extlib/string' # String#/, because I'm a lazy fuck.
 require 'rake'
-require 'rake/rdoctask'
+require 'yard'
+require 'yard/rake/yardoc_task'
 require 'spec/rake/spectask'
 require 'spec/rake/verify_rcov'
+require 'stringray/core_ext/spec/rake/verify_rcov'
 
 begin
   require 'echoe'
   
-  namespace :echoe do
-    Echoe.new('StringRay', StringRay::VERSION) do |g|
-      g.name = 'stringray'
+  task :package => :'package:package'
+  task :install => :'package:install'
+  task :manifest => :'package:manifest'
+  namespace :package do
+    Echoe.new('stringray', StringRay::Version) do |g|
+      g.project = 'stringray'
       g.author = ['elliottcable']
       g.email = ['StringRay@elliottcable.com']
       g.summary = 'Combining many of the benefits of Arrays and Strings, StringRay allows you to treat a String as an Array of words in many cases.'
       g.url = 'http://github.com/elliottcable/stringray'
       g.dependencies = []
+      g.development_dependencies = ['elliottcable-echoe >= 3.0.2', 'rspec', 'rcov', 'yard']
       g.manifest_name = '.manifest'
-      g.ignore_pattern = ['.git', 'meta', 'stringray.gemspec']
+      g.retain_gemspec = true
+      g.rakefile_name = 'Rakefile.rb'
+      g.ignore_pattern = /(^\.git$|^\.yardoc$|^meta\/|\.gemspec$)/
     end
   
     desc 'tests packaged files to ensure they are all present'
     task :verify => :package do
       # An error message will be displayed if files are missing
-      if system %(ruby -e "require 'rubygems'; require 'pkg/merb_strokedb-#{StringRay::VERSION}/lib/stringray'")
+      if system %(ruby -e "require 'rubygems'; require 'pkg/stringray-#{StringRay::VERSION}/lib/stringray'")
         puts "\nThe library files are present"
       end
     end
-
-    task :copy_gemspec => [:package] do
-      pkg = Dir['pkg/*'].select {|dir| File.directory? dir}.last
-      mv File.join(pkg, pkg.gsub(/^pkg\//,'').gsub(/\-\d+$/,'.gemspec')), './'
-    end
-
-    desc 'builds a gemspec as GitHub wants it'
-    task :gemspec => [:package, :copy_gemspec, :clobber_package]
-
-    # desc 'Run specs, clean tree, update manifest, run coverage, and install gem!'
-    desc 'Clean tree, update manifest, and install gem!'
-    task :magic => [:clean, :manifest, :install]
   end
   
-  task :manifest => [:'echoe:manifest']
-  
 rescue LoadError => boom
   puts "You are missing a dependency required for meta-operations on this gem."
   puts "#{boom.to_s.capitalize}."
@@ -57,6 +51,7 @@ ensure
       t.spec_files = Dir['spec/**/*_spec.rb'].sort
       t.libs = ['lib']
       t.rcov = true
+      t.rcov_opts = ['--exclude-only', '".*"', '--include-file', '^lib']
       t.rcov_dir = 'meta' / 'coverage'
     end
 
@@ -70,8 +65,9 @@ ensure
     end
 
     RCov::VerifyTask.new(:verify) do |t|
-      t.threshold = 100
+      t.threshold = 98.7
       t.index_html = 'meta' / 'coverage' / 'index.html'
+      t.require_exact_threshold = false
     end
 
     task :open do
@@ -79,15 +75,42 @@ ensure
     end
   end
   
+  namespace :yard do
+    YARD::Rake::YardocTask.new :generate do |t|
+      t.files   = ['lib/**/*.rb']
+      t.options = ['--output-dir', "meta/documentation", '--readme', 'README.markdown']
+    end
+    
+    YARD::Rake::YardocTask.new :dot_yardoc do |t|
+      t.files   = ['lib/**/*.rb']
+      t.options = ['--no-output', '--readme', 'README.markdown']
+    end
+    
+    task :open do
+      system 'open ' + 'meta' / 'documentation' / 'index.html' if PLATFORM['darwin']
+    end
+  end
+  
   namespace :git do
     task :status do
       `git status`
     end
+    
+    task :commit => [:'echoe:manifest', :'yard:dot_yardoc'] do
+      `git commit`
+    end
+  end
+  
+  task :clobber => [:'echoe:clobber_package', :'echoe:clobber_docs', :'echoe:clobber_coverage'] do
+    rm_f 'meta'
   end
 
   desc 'Check everything over before commiting'
-  task :aok => [:'echoe:manifest', :'rcov:run', :'rcov:verify', :'rcov:ratio', :'rcov:open', :'git:status']
+  task :aok => [:'yard:generate', :'yard:open',
+                :'package:manifest', :'package:package',
+                :'rcov:run', :'rcov:verify', :'rcov:open',
+                :'git:status']
 
   # desc 'Task run during continuous integration' # Invisible
-  task :cruise => [:'rcov:plain', :'rcov:verify', :'rcov:ratio']
-end
+  task :ci => [:'yard:generate', :'rcov:plain', :'rcov:verify']
+end

data/lib/stringray.rb

@@ -1,120 +1,199 @@
+require 'stringray/core_ext'
+
 module StringRay
-  VERSION = 2
+  Version = 3
   
-  # Splits a string into words. Not using the obvious names (+#split+, +#words+)
-  # because I want compatibility for inclusion into +String+.
-  def enumerate
+  @@whitespace = nil
+  @@delemiters = nil
+  
+  ##
+  # @see #enumerate
+  # Controls how +#enumerate+ deals with whitespace.
+  # 
+  # @param [Symbol] whitespace How to handle whitespace - :attach_before,
+  #   :standalone, or :attach_after
+  def self.whitespace= whitespace
+    @@whitespace = whitespace
+  end
+  
+  def self.whitespace
+    @@whitespace ||= :attach_before
+  end
+
+  ##
+  # @see #enumerate
+  # Controls how +#enumerate+ deals with delemiters.
+  # 
+  # @param [Symbol] delemiters How to handle delemiters - :attach_before,
+  #   :standalone, or :attach_after
+  def self.delemiters= delemiters
+    @@delemiters = delemiters
+  end
+  
+  def self.delemiters
+    @@delemiters ||= :attach_before
+  end
+  
+  ##
+  # Splits a string into an array of +StringRay+ container objects (+Word+,
+  # +Whitespace+, and +Delimiter+).
+  # 
+  # @yield [element] Allows each 'element' of the string to be operated on
+  #   after it is processed
+  # @yieldparam [Word, Whitespace, Delimiter] element The last processed
+  #   string 'element'
+  # @return [Array[Word, Whitespace, Delimiter]] An array of +StringRay+
+  #   container objects
+  # @since 2
+  def to_stray
     ray = []
+    new_element = lambda do |element|
+      yield ray.last if block_given? unless ray.empty?
+      ray << element
+    end
     
-    self.each_byte do |byte|
-      char = byte.chr
-      
+    self.scan(/./um) do |char|
       if Delimiter::Characters.include? char
-        ray << Delimiter.new(char)
+        new_element[Delimiter.new(char)]
         
       elsif Whitespace::Characters.include? char
         if ray.last.is_a? Whitespace
           ray.last << char
         else
-          ray << Whitespace.new(char)
+          new_element[Whitespace.new(char)]
         end
         
       else
         if ray.last.is_a? Word
           ray.last << char
         else
-          ray << Word.new(char)
+          new_element[Word.new(char)]
         end
         
       end
     end
     
-    ray
+    if block_given?
+      yield ray.last
+      self
+    else
+      ray
+    end
   end
   
-  # More sensible than +String#each+, this uses +#enumerate+ to enumerate on
-  # words. Accepts options as a hash, determining whether :whitespace and
-  # :delemiters will :attach_before, :standalone, or :attach_after. Default is
-  # for both to :attach_before.
-  def each_word opts = {}, &block
-    {:whitespace => :attach_before, :delemiters => :attach_before}.merge! opts
-    
-    # First, we create a two-dimensional array of words with any whitespace or
-    # delemiters that should attach to them.
-    words = self.enumerate
+  ##
+  # @see #to_stray
+  # @see #whitespace
+  # @see #delemiters
+  # Enumerates a string, similar to +#to_stray+, but returning an array of
+  # plain +String+s instead of container objects.
+  # 
+  # @param [Hash] options A hash of options
+  # @yield [word] Allows each word in the string to be operated on after it is
+  #   processed
+  # @yieldparam [String] word The last processed word
+  # @return [Array[String]] An array of words
+  # @since 1
+  def enumerate options = {}, &block
     mapped = []
     attach_before_next = []
     
-    words.each do |item|
-      case item
+    self.to_stray do |element|
+      case element
       when Delimiter
-        case opts[:delemiters]
+        case options[:delemiters] || StringRay::delemiters
         when :standalone
-          mapped << [item]
+          mapped << [element]
         when :attach_after
-          attach_before_next << item
+          attach_before_next << element
         else
           if attach_before_next.empty?
             if mapped.last
-              mapped.last << item
+              mapped.last << element
             else
-              attach_before_next << item
+              attach_before_next << element
             end
           else
-            attach_before_next << item
+            attach_before_next << element
           end
         end
         
       when Whitespace
-        case opts[:whitespace]
+        case options[:whitespace] || StringRay::whitespace
         when :standalone
-          mapped << [item]
+          mapped << [element]
         when :attach_after
-          attach_before_next << item
+          attach_before_next << element
         else
           if attach_before_next.empty?
             if mapped.last
-              mapped.last << item
+              mapped.last << element
             else
-              attach_before_next << item
+              attach_before_next << element
             end
           else
-            attach_before_next << item
+            attach_before_next << element
           end
         end
         
       when Word
         if not attach_before_next.empty?
-          mapped << [attach_before_next, item].flatten
+          mapped << [attach_before_next, element].flatten
           attach_before_next = []
         else
-          mapped << [item]
+          mapped << [element]
         end
         
       end
     end
-    (mapped.last << attach_before_next).flatten! if not attach_before_next.empty?
     
-    # Next, we yield each group of (word plus delimiters and whitespace) as a
-    # normal string to the block
-    mapped.each do |arr|
-      yield arr.map{|w|w.to_s}.join
+    if not attach_before_next.empty?
+      mapped << [Word.new] unless mapped.last
+      (mapped.last << attach_before_next).flatten!
+    end
+    
+    mapped.map do |arr|
+      string = arr.map{|w|w.to_s}.join
+      yield string if block_given?
+      string
     end
   end
   
+  # @deprecated
+  alias_method :each_word, :enumerate
+  
+  # @see StringRay::Word.new
+  def Word word; Word.new word; end
+  
+  ##
+  # A wrapper class for strings that are 'words' in and of themselves,
+  # composed of 'word characters'.
   class Word < String
     def inspect
       "(#{self})"
     end
   end
   
+  # @see StringRay::Whitespace.new
+  def Whitespace whitespace; Whitespace.new whitespace; end
+  
+  ##
+  # A wrapper class for strings that are 'whitespace' composed of 'whitespace
+  # characters'.
   class Whitespace < String
     Characters = [" ", "\t", "\n"]
+    
     def inspect
       "#{self}"
     end
   end
   
+  # @see StringRay::Delimiter.new
+  def Delimiter delimiter; Delimiter.new delimiter; end
+  
+  ##
+  # A wrapper class for strings that are 'delimiters' composed of 'delimiter
+  # characters'.
   class Delimiter < String
     Characters = ['-', ',', '.', '?', '!', ':', ';', '/', '\\', '|']
     
@@ -123,14 +202,31 @@ module StringRay
     end
   end
   
-  # This overrides +String#each+ with +StringRay#each_word+, thus allowing us
-  # to include +Enumerable+.
-  def self.included klass
-    klass.class_eval do
-      alias_method :each_at, :each
-      alias_method :each, :each_word
-      
-      include Enumerable
+  # This is mixed into any class including +StringRay+. It exposes
+  # +::make_enumerable!+ to said class.
+  module Extendables
+    
+    ##
+    # This overrides +String#each+ with +StringRay#enumerate+, thus allowing
+    # us to include +Enumerable+. Be careful, this breaks lots of existing
+    # code which depends on the old methodology of +String#each+! The
+    # overridden +String#each+ functionality will be exposed as
+    # +String#each_at+.
+    def make_enumerable!
+      self.class_eval do
+        if RUBY_VERSION <= "1.9"
+          Kernel::warn "overriding String#each with StringRay#enumerate; this may break old libaries!"
+          alias_method :each_at, :each
+        end
+        alias_method :each, :enumerate
+        
+        include Enumerable
+      end
     end
+    
+  end
+  
+  def self.included klass
+    klass.send :extend, Extendables
   end
-end
+end

data/lib/stringray/core_ext.rb

@@ -0,0 +1 @@
+require 'stringray/core_ext/kernel'

data/lib/stringray/core_ext/kernel.rb

@@ -0,0 +1,6 @@
+module Kernel
+  def self.warn message
+    super "#{caller[-1]}: warning: #{message}"
+  end
+end
+

data/lib/stringray/core_ext/spec/rake/verify_rcov.rb

@@ -0,0 +1,23 @@
+class RCov::VerifyTask
+  
+  # For now, it appears that StringRay's habit of fucking with #each, also
+  # screws with RCov generation. RSpec's verification task's fragile code
+  # doesn't like that... so let's fix it.
+  def define
+    desc "Verify that rcov coverage is at least #{threshold}%"
+    task @name do
+      total_coverage = nil
+
+      File.open(index_html).each_line do |line|
+        if line =~ /<tt\s+class='coverage_total'>\s*(\d+\.\d+)%\s*<\/tt>/
+          total_coverage = $1.to_s.to_f
+          break
+        end
+      end
+      puts "Coverage: #{total_coverage}% (threshold: #{threshold}%)" if verbose
+      raise "Coverage must be at least #{threshold}% but was #{total_coverage}%" if total_coverage < threshold
+      raise "Coverage has increased above the threshold of #{threshold}% to #{total_coverage}%. You should update your threshold value." if (total_coverage > threshold) and require_exact_threshold
+    end
+  end
+  
+end

data/spec/stringray_spec.rb

@@ -1,108 +1,177 @@
 ($:.unshift File.expand_path(File.join( File.dirname(__FILE__), '..', 'lib' ))).uniq!
 require 'stringray'
 
+# Some shortcusts, because the author is a lazy typist...
+def Word word;              StringRay::Word.new word;             end
+def Whitespace whitespace;  StringRay::Whitespace.new whitespace; end
+def Delimiter delimiter;    StringRay::Delimiter.new delimiter;   end
+Space   = Whitespace ' '
+Period  = Delimiter '.'
+
 describe 'a String including StringRay' do
   before :all do
-    String.send :include, StringRay
+    class String
+      include StringRay
+    end
+  end
+  
+  describe "#to_stray" do
+    it "should return a multi-dimensional array of container elements" do
+      string = 'This is a string.'
+      string.to_stray.should ==
+        [Word('This'), Space, Word('is'), Space, Word('a'), Space, Word('string'), Period]
+    end
+    
+    it "should yield each text element if passed a block" do
+      string = 'This is a string.'
+      
+      yielded = []
+      string.to_stray do |element|
+        yielded << element
+      end
+      
+      yielded.should ==
+        [Word('This'), Space, Word('is'), Space, Word('a'), Space, Word('string'), Period]
+    end
   end
   
   describe '#enumerate' do
     it 'should split a string into an array' do
-      string = 'The time has come to talk of many things - of sailing ' +
-        'ships and sealing wax, of cabbages and kings!'
-      string.inject([]) {|a, i| a << i }.should == 
-        ['The ','time ','has ','come ','to ','talk ','of ',
-        'many ','things - ','of ','sailing ','ships ','and ','sealing ',
-        'wax, ','of ','cabbages ','and ','kings!']
+      string = 'This is a string'
+      string.enumerate.should == 
+        ['This ','is ','a ','string']
     end
     
     it 'should correctly treat commas and lists' do
-      string = 'I have commas, periods, and other punctuation'
-      string.inject([]) {|a, i| a << i }.should == 
-        ['I ','have ','commas, ','periods, ','and ','other ','punctuation']
+      string = 'Commas, commas, commas'
+      string.enumerate.should == 
+        ['Commas, ','commas, ','commas']
     end
     
-    it 'should correctly treat periods and end-of-sentance demarcators' do
-      string = 'Periods. Cool right? Yah!'
-      string.inject([]) {|a, i| a << i }.should == 
-        ['Periods. ','Cool ','right? ','Yah!']
+    it 'should correctly treat periods and end-of-sentence demarcators' do
+      string = 'Punctuation. Cool right? Yah!'
+      string.enumerate.should == 
+        ['Punctuation. ','Cool ','right? ','Yah!']
     end
     
     it 'should correctly treat dahses' do
-      string = 'I have - uh - dashes!'
-      string.inject([]) {|a, i| a << i }.should == 
-        ['I ','have - ','uh - ','dashes!']
+      string = 'I have - uh - dashes'
+      string.enumerate.should == 
+        ['I ','have - ','uh - ','dashes']
     end
     
     it 'should correctly treat ellipses' do
-      string = 'Where are we... going?'
-      string.inject([]) {|a, i| a << i }.should == 
-        ['Where ','are ','we... ','going?']
+      string = 'Where... are we... going'
+      string.enumerate.should == 
+        ['Where... ','are ','we... ','going']
     end
     
     it 'should correctly treat a delimated word' do
-      string = 'String and Array, sitting in a tree - K-I-S-S-I-N-G!'
-      string.inject([]) {|a, i| a << i }.should == 
-        ['String ','and ','Array, ','sitting ','in ','a ','tree - ','K-','I-','S-','S-','I-','N-','G!']
+      string = 'Pneumono-ultra-microscopic-silico-volcano-koniosis'
+      string.enumerate.should == 
+        ['Pneumono-','ultra-','microscopic-','silico-','volcano-','koniosis']
     end
     
     it 'should correctly treat inline line returns' do
-      string = "This has\na line return!"
-      string.inject([]) {|a, i| a << i }.should == 
-        ["This ","has\n","a ","line ","return!"]
+      string = "Line\nreturns\nyay"
+      string.enumerate.should == 
+        ["Line\n","returns\n","yay"]
     end
     
     it 'should correctly treat prefacing line returns and whitespace' do
-      string = "\n  Now it starts!\n\n"
-      string.inject([]) {|a, i| a << i }.should == 
-        ["\n  Now ","it ","starts!\n\n"]
-    end
-  end
-  
-  describe '#each_word' do
-    it 'should be able to attach delimeters to the beginning of the next word' do
-      string = 'The time has come to talk of many things - of sailing ' +
-        'ships and sealing wax, of cabbages and kings!'
-      array = []
-      string.each(:delemiters => :attach_after) {|i| array << i }
-      array.should == ['The ','time ','has ','come ','to ','talk ','of ',
-        'many ','things ','- of ','sailing ','ships ','and ','sealing ',
-        'wax',', of ','cabbages ','and ','kings!']
+      string = "\n\t # Code\n\n"
+      string.enumerate.should == 
+        ["\n\t # ","Code\n\n"]
     end
     
-    it 'should be able to let delimeters stand alone' do
-      string = 'The time has come to talk of many things - of sailing ' +
-        'ships and sealing wax, of cabbages and kings!'
-      array = []
-      string.each(:delemiters => :standalone) {|i| array << i }
-      array.should == ['The ','time ','has ','come ','to ','talk ','of ',
-        'many ','things ','- ', 'of ','sailing ','ships ','and ','sealing ',
-        'wax',', ','of ','cabbages ','and ','kings','!']
-    end
+    describe '(method options hash)' do
+      it 'should be able to attach delimeters to the beginning of the next word' do
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate(:delemiters => :attach_after).should == 
+          ['The ','time ','has ','come ','to ','talk ','of ',
+          'many ','things ','- of ','sailing ','ships ','and ','sealing ',
+          'wax',', of ','cabbages ','and ','kings!']
+      end
+    
+      it 'should be able to let delimeters stand alone' do
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate(:delemiters => :standalone).should ==
+          ['The ','time ','has ','come ','to ','talk ','of ',
+          'many ','things ','- ', 'of ','sailing ','ships ','and ','sealing ',
+          'wax',', ','of ','cabbages ','and ','kings','!']
+      end
     
-    it 'should be able to attach whitespace to the beginning of the next word' do
-      string = 'The time has come to talk of many things - of sailing ' +
-        'ships and sealing wax, of cabbages and kings!'
-      array = []
-      string.each(:whitespace => :attach_after) {|i| array << i }
-      array.should == ['The',' time',' has',' come',' to',' talk',' of',
-        ' many',' things',' - of',' sailing',' ships',' and',' sealing',
-        ' wax,',' of',' cabbages',' and',' kings!']
+      it 'should be able to attach whitespace to the beginning of the next word' do
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate(:whitespace => :attach_after).should ==
+          ['The',' time',' has',' come',' to',' talk',' of',
+          ' many',' things',' - of',' sailing',' ships',' and',' sealing',
+          ' wax,',' of',' cabbages',' and',' kings!']
+      end
+    
+      it 'should be able to let whitespace stand alone' do
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate(:whitespace => :standalone).should ==
+          ['The',' ','time',' ','has',' ','come',' ','to',' ','talk',' ','of',
+          ' ','many',' ','things',' -',' ','of',' ','sailing',' ','ships',' ','and',' ','sealing',
+          ' ','wax,',' ','of',' ','cabbages',' ','and',' ','kings!']
+      end
     end
     
-    it 'should be able to let whitespace stand alone' do
-      string = 'The time has come to talk of many things - of sailing ' +
-        'ships and sealing wax, of cabbages and kings!'
-      array = []
-      string.each(:whitespace => :standalone) {|i| array << i }
-      array.should == ['The',' ','time',' ','has',' ','come',' ','to',' ','talk',' ','of',
-        ' ','many',' ','things',' -',' ','of',' ','sailing',' ','ships',' ','and',' ','sealing',
-        ' ','wax,',' ','of',' ','cabbages',' ','and',' ','kings!']
+    describe '(class setter methods)' do
+      before :each do
+        StringRay::whitespace = nil
+        StringRay::delemiters = nil
+      end
+      
+      it 'should allow delemiter handling to be set through a class method' do
+        StringRay::whitespace = :attach_after
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate.should ==
+          ['The',' time',' has',' come',' to',' talk',' of',
+          ' many',' things',' - of',' sailing',' ships',' and',' sealing',
+          ' wax,',' of',' cabbages',' and',' kings!']
+        
+        StringRay::whitespace = :standalone
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate.should ==
+          ['The',' ','time',' ','has',' ','come',' ','to',' ','talk',' ','of',
+          ' ','many',' ','things',' -',' ','of',' ','sailing',' ','ships',' ','and',' ','sealing',
+          ' ','wax,',' ','of',' ','cabbages',' ','and',' ','kings!']
+      end
+      
+      it 'should allow whitespace handling to be set through a class method' do
+        StringRay::whitespace = :attach_after
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate.should ==
+          ['The',' time',' has',' come',' to',' talk',' of',
+          ' many',' things',' - of',' sailing',' ships',' and',' sealing',
+          ' wax,',' of',' cabbages',' and',' kings!']
+        
+        StringRay::whitespace = :standalone
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate.should ==
+          ['The',' ','time',' ','has',' ','come',' ','to',' ','talk',' ','of',
+          ' ','many',' ','things',' -',' ','of',' ','sailing',' ','ships',' ','and',' ','sealing',
+          ' ','wax,',' ','of',' ','cabbages',' ','and',' ','kings!']
+      end
     end
   end
   
-  # TODO: Figure out a better way to say 'should be_include(Enumerable)'
-  it 'should also include enumerable' do
-    String.ancestors.should be_include(Enumerable)
+  it 'should be capable of making String enumerable' do
+    class ExtendedString < String
+      include StringRay
+      make_enumerable!
+    end
+    
+    ExtendedString.ancestors.should be_include(Enumerable)
   end
 end

data/stringray.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{stringray}
+  s.version = "3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["elliottcable"]
+  s.date = %q{2009-06-11}
+  s.description = %q{Combining many of the benefits of Arrays and Strings, StringRay allows you to treat a String as an Array of words in many cases.}
+  s.email = ["StringRay@elliottcable.com"]
+  s.extra_rdoc_files = ["lib/stringray.rb", "lib/stringray/core_ext.rb", "lib/stringray/core_ext/kernel.rb", "lib/stringray/core_ext/spec/rake/verify_rcov.rb", "README.markdown"]
+  s.files = ["lib/stringray.rb", "lib/stringray/core_ext.rb", "lib/stringray/core_ext/kernel.rb", "lib/stringray/core_ext/spec/rake/verify_rcov.rb", "spec/stringray_spec.rb", "README.markdown", "Rakefile.rb", ".manifest", "stringray.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/elliottcable/stringray}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Stringray", "--main", "README.markdown"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{stringray}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Combining many of the benefits of Arrays and Strings, StringRay allows you to treat a String as an Array of words in many cases.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<elliottcable-echoe>, [">= 0", "= 3.0.2"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+    else
+      s.add_dependency(%q<elliottcable-echoe>, [">= 0", "= 3.0.2"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<elliottcable-echoe>, [">= 0", "= 3.0.2"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+  end
+end

metadata

@@ -1,18 +1,52 @@
 --- !ruby/object:Gem::Specification 
 name: elliottcable-stringray
 version: !ruby/object:Gem::Version 
-  version: "2"
+  version: "3"
 platform: ruby
 authors: 
 - elliottcable
 autorequire: 
 bindir: bin
-cert_chain: 
-date: 2008-08-12 01:00:00 -07:00
+cert_chain: []
+
+date: 2009-06-11 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: echoe
+  name: elliottcable-echoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 3.0.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yard
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
@@ -30,14 +64,20 @@ extensions: []
 
 extra_rdoc_files: 
 - lib/stringray.rb
-- README.mkdn
+- lib/stringray/core_ext.rb
+- lib/stringray/core_ext/kernel.rb
+- lib/stringray/core_ext/spec/rake/verify_rcov.rb
+- README.markdown
 files: 
 - lib/stringray.rb
-- Rakefile
-- README.mkdn
+- lib/stringray/core_ext.rb
+- lib/stringray/core_ext/kernel.rb
+- lib/stringray/core_ext/spec/rake/verify_rcov.rb
 - spec/stringray_spec.rb
+- README.markdown
+- Rakefile.rb
 - .manifest
-- StringRay.gemspec
+- stringray.gemspec
 has_rdoc: true
 homepage: http://github.com/elliottcable/stringray
 post_install_message: 
@@ -45,9 +85,9 @@ rdoc_options:
 - --line-numbers
 - --inline-source
 - --title
-- StringRay
+- Stringray
 - --main
-- README.mkdn
+- README.markdown
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -58,7 +98,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - "="
+  - - ">="
     - !ruby/object:Gem::Version 
       version: "1.2"
   version: 

data/README.mkdn

@@ -1,41 +0,0 @@
-StringRay
-=========
-
-**StringRay** exposes a powerful method to split a `String` into an `Array` of words,
-and further allows you to include `Enumerable`, thus exposing many of the
-most useful `Array` methods on your `String`s.
-
-Usage
------
-    
-    class String; include StringRay; end
-    
-    "Oi! I'm a string, do something fun with me!".each do |word|
-      p word
-    end
-    
-Getting
--------
-
-The authoritative source for this project is available at
-<http://github.com/elliottcable/stringray>. You can clone your own copy with the
-following command:
-
-    git clone git://github.com/elliottcable/stringray.git
-
-If you want to make changes to the codebase, you need to fork your own GitHub
-repository for said changes. Send a pullrequest to [elliottcable](http://github.com/elliottcable "elliottcable on GitHub")
-when you've got something ready for the master branch that you think should be
-merged.
-
-Requirements
-------------
-
-To run git-blog, you need... nothing!
-
-To develop and contribute to git-blog, you also need:
-
-* `gem install rake`
-* `gem install rspec`
-* `gem install rcov`
-* `gem install echoe`