elliottcable-stringray 2

data/.manifest

@@ -0,0 +1,5 @@
+lib/stringray.rb
+Rakefile
+README.mkdn
+spec/stringray_spec.rb
+.manifest

data/README.mkdn

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

data/Rakefile

@@ -0,0 +1,93 @@
+($:.unshift File.expand_path(File.join( File.dirname(__FILE__), 'lib' ))).uniq!
+require 'stringray'
+require 'extlib/string' # String#/, because I'm a lazy fuck.
+require 'rake'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
+begin
+  require 'echoe'
+  
+  namespace :echoe do
+    Echoe.new('StringRay', StringRay::VERSION) do |g|
+      g.name = '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.manifest_name = '.manifest'
+      g.ignore_pattern = ['.git', 'meta', 'stringray.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'")
+        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}."
+ensure
+  task :default # No effect # Invisible
+
+  # Runs specs, generates rcov, and opens rcov in your browser.
+  namespace :rcov do
+    Spec::Rake::SpecTask.new(:run) do |t|
+      t.spec_opts = ["--format", "specdoc", "--colour"]
+      t.spec_files = Dir['spec/**/*_spec.rb'].sort
+      t.libs = ['lib']
+      t.rcov = true
+      t.rcov_dir = 'meta' / 'coverage'
+    end
+
+    Spec::Rake::SpecTask.new(:plain) do |t|
+      t.spec_opts = ["--format", "specdoc"]
+      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
+
+    RCov::VerifyTask.new(:verify) do |t|
+      t.threshold = 100
+      t.index_html = 'meta' / 'coverage' / 'index.html'
+    end
+
+    task :open do
+      system 'open ' + 'meta' / 'coverage' / 'index.html' if PLATFORM['darwin']
+    end
+  end
+  
+  namespace :git do
+    task :status do
+      `git status`
+    end
+  end
+
+  desc 'Check everything over before commiting'
+  task :aok => [:'echoe:manifest', :'rcov:run', :'rcov:verify', :'rcov:ratio', :'rcov:open', :'git:status']
+
+  # desc 'Task run during continuous integration' # Invisible
+  task :cruise => [:'rcov:plain', :'rcov:verify', :'rcov:ratio']
+end

data/lib/stringray.rb

@@ -0,0 +1,136 @@
+module StringRay
+  VERSION = 2
+  
+  # Splits a string into words. Not using the obvious names (+#split+, +#words+)
+  # because I want compatibility for inclusion into +String+.
+  def enumerate
+    ray = []
+    
+    self.each_byte do |byte|
+      char = byte.chr
+      
+      if Delimiter::Characters.include? char
+        ray << Delimiter.new(char)
+        
+      elsif Whitespace::Characters.include? char
+        if ray.last.is_a? Whitespace
+          ray.last << char
+        else
+          ray << Whitespace.new(char)
+        end
+        
+      else
+        if ray.last.is_a? Word
+          ray.last << char
+        else
+          ray << Word.new(char)
+        end
+        
+      end
+    end
+    
+    ray
+  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
+    mapped = []
+    attach_before_next = []
+    
+    words.each do |item|
+      case item
+      when Delimiter
+        case opts[:delemiters]
+        when :standalone
+          mapped << [item]
+        when :attach_after
+          attach_before_next << item
+        else
+          if attach_before_next.empty?
+            if mapped.last
+              mapped.last << item
+            else
+              attach_before_next << item
+            end
+          else
+            attach_before_next << item
+          end
+        end
+        
+      when Whitespace
+        case opts[:whitespace]
+        when :standalone
+          mapped << [item]
+        when :attach_after
+          attach_before_next << item
+        else
+          if attach_before_next.empty?
+            if mapped.last
+              mapped.last << item
+            else
+              attach_before_next << item
+            end
+          else
+            attach_before_next << item
+          end
+        end
+        
+      when Word
+        if not attach_before_next.empty?
+          mapped << [attach_before_next, item].flatten
+          attach_before_next = []
+        else
+          mapped << [item]
+        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
+    end
+  end
+  
+  class Word < String
+    def inspect
+      "(#{self})"
+    end
+  end
+  
+  class Whitespace < String
+    Characters = [" ", "\t", "\n"]
+    def inspect
+      "#{self}"
+    end
+  end
+  
+  class Delimiter < String
+    Characters = ['-', ',', '.', '?', '!', ':', ';', '/', '\\', '|']
+    
+    def inspect
+      "<#{self}>"
+    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
+    end
+  end
+end

data/spec/stringray_spec.rb

@@ -0,0 +1,108 @@
+($:.unshift File.expand_path(File.join( File.dirname(__FILE__), '..', 'lib' ))).uniq!
+require 'stringray'
+
+describe 'a String including StringRay' do
+  before :all do
+    String.send :include, StringRay
+  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!']
+    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']
+    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!']
+    end
+    
+    it 'should correctly treat dahses' do
+      string = 'I have - uh - dashes!'
+      string.inject([]) {|a, i| a << i }.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?']
+    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!']
+    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!"]
+    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!']
+    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
+    
+    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!']
+    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!']
+    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)
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: elliottcable-stringray
+version: !ruby/object:Gem::Version 
+  version: "2"
+platform: ruby
+authors: 
+- elliottcable
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2008-08-12 01:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: echoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Combining many of the benefits of Arrays and Strings, StringRay allows you to treat a String as an Array of words in many cases.
+email: 
+- StringRay@elliottcable.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/stringray.rb
+- README.mkdn
+files: 
+- lib/stringray.rb
+- Rakefile
+- README.mkdn
+- spec/stringray_spec.rb
+- .manifest
+- StringRay.gemspec
+has_rdoc: true
+homepage: http://github.com/elliottcable/stringray
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- StringRay
+- --main
+- README.mkdn
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - "="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: stringray
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+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.
+test_files: []
+