stubber 0.1.1

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+.bundle
+*.rbc
+*.tmproj
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+-cfs
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in stubber.gemspec
+gemspec

data/README.md

@@ -0,0 +1,53 @@
+# Stubber
+
+Stubber is a simple gem that lets you stub strings, using "words" as the unit of measure.  For example:
+
+        require 'stubber'
+        require 'lorem' # Or just add your own text
+
+        str = Lorem::Base.new('paragraphs', 1).output
+        # => "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vivamus vitae risus vitae lorem iaculis placerat."
+
+        # Get the first 5 words
+        str.stub_words(5)
+        # => "Lorem ipsum dolor sit amet"
+
+        # Get the NEXT 5 words
+        str.stub_words(5, true)
+        # => ", consectetuer adipiscing elit. Vivamus vitae"
+
+        # Grab the _complete_ words, appearing _up to_ position 20
+        str.stub_to(70)
+        # => "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vivamus "
+
+        str.stub_to(70).size
+        # => 66
+
+        # Grab the _complete_ words, appearing _through_ position 20
+        str.stub_thru(70)
+        # => "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vivamus vitae"
+
+        str.stub_thru(70).size
+        # => 71
+
+Now the other direction!
+
+        str.stub_words(-5)
+        # => "risus vitae lorem iaculis placerat."
+
+        str.stub_words(-5, true)
+        # => "consectetuer adipiscing elit. Vivamus vitae "
+
+        str.stub_to(-45)
+        # => " vitae risus vitae lorem iaculis placerat."
+
+        str.stub_to(-45).size
+        # => 42
+
+So far, so good!  Suggestions are welcome.
+
+# TODO
+
+*   stubbing from the right direction is simple to do and will be the next addition.
+    *   *^* done, needs specs
+*   left and right indexes

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+task :release => :spec
+
+desc "Run Specs"
+Rspec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern    = "spec/**/*_spec.rb"
+  spec.verbose    = true
+  spec.rspec_opts = ['--color']
+end
+
+require 'yard'
+
+desc "Generate YARD docs"
+YARD::Rake::YardocTask.new(:yard) do |t|
+  t.files += ['lib/**/*.rb']
+end

data/lib/stubber.rb

@@ -0,0 +1,11 @@
+require 'strscan'
+require 'stubber/base'
+require 'stubber/core_ext'
+
+module Stubber
+  extend Stubber::Base
+end
+
+class String
+  include Stubber::CoreExt
+end

data/lib/stubber/base.rb

@@ -0,0 +1,60 @@
+require 'stubber/version'
+
+module Stubber
+  autoload :CoreExt, 'stubber/core_ext'
+
+  module Base
+    WORD = /\w+[\!\.\?]*[^\s,]/
+
+    # Stubs a given text string, up to a given number of words
+    #   @param [String] text      Any piece of text
+    #   @param [Fixnum] max_words The desired number of words
+    #   @return [String] The text, stubbed at max_words number of words
+    def stub_words(text, max_words)
+      scanner = StringScanner.new(text.to_s)
+
+      return scan_words(scanner, max_words)
+    end
+
+    # Stubs the given text string a number of whole-words, not to go beyond the given text position
+    #   @param [String] text      Any piece of text
+    #   @param [Fixnum] max_text  Text position that delimits the desired number of whole words
+    #   @return [String] The text, stubbed at the max_text position
+    def stub_text(text, max_text)
+      scanner = StringScanner.new(text.to_s)
+
+      return scan_text(scanner, max_text)
+    end
+
+    # Scans ahead one word position, and returns it
+    #   @param [StringScanner] scanner
+    #   @return [String]
+    def scan_word(scanner)
+      scanner.scan_until(WORD)
+    end
+
+    # Scans a given number of words from a scanner
+    #   @param [StringScanner]
+    #   @param [Fixnum]
+    #   @return [String]
+    def scan_words(scanner, max_words)
+      words = max_words.times.map {
+                scan_word(scanner)
+              }
+      words.compact!
+      words.join
+    end
+
+    # Scans a given number of words, up to a given character position (but not beyond)
+    #   @param [StringScanner]
+    #   @param [Fixnum]
+    #   @return [String]
+    def scan_text(scanner, max_text)
+      start = scanner.pos
+
+      until scanner.pos >= (max_text + start) || scan_word(scanner).nil?; end
+
+      (scanner.pre_match || scanner.string[start, max_text]).to_s
+    end
+  end # module Base
+end # module Stubber

data/lib/stubber/core_ext.rb

@@ -0,0 +1,111 @@
+require 'stubber/base'
+
+module Stubber
+  module CoreExt
+    include Stubber::Base
+
+    # @return [StringScanner]
+    def scanner
+      @scanner ||= StringScanner.new(self)
+    end
+
+    #   @param [Fixnum]
+    #   @param [true, false]
+    #   @return [String]
+    def stub_words(max_words, save_pos=false)
+      scanner.reset unless save_pos
+
+      if max_words < 0
+        rev_stub_words(max_words.abs, save_pos)
+      else
+        scan_words(scanner, max_words)
+      end
+    end
+    alias :stub   :stub_words
+    alias :words  :stub_words
+
+    #   @param [Fixnum]
+    #   @param [true, false]
+    #   @return [String]
+    def stub_at_most(max_chars, save_pos=false)
+      scanner.reset unless save_pos
+
+      str = if max_chars < 0
+              rev_stub_at_most(max_chars.abs, save_pos)
+            else
+              scan_text(scanner, max_chars)
+            end
+
+      begin
+        scanner.unscan if str.empty? && scanner.pos > max_chars && !scanner.pre_match.nil?
+      rescue StringScanner::Error => e
+        # Do nothing
+      end
+
+      return str
+    end
+    alias :stub_text  :stub_at_most
+    alias :stub_chars :stub_at_most
+    alias :stub_pos   :stub_at_most
+    alias :stub_to    :stub_at_most
+
+    #   @param [Fixnum]
+    #   @param [true, false]
+    #   @return [String]
+    def stub_at_least(min_chars, save_pos=false)
+      scanner.reset unless save_pos
+
+      if min_chars < 0
+        return rev_stub_at_least(min_chars.abs, save_pos)
+      end
+
+      start = scanner.pos
+      str   = scan_text(scanner, min_chars)
+
+      if(str.size < (min_chars + start))
+        str << scanner.matched.to_s
+      end
+
+      str
+    end
+    alias :stub_thru    :stub_at_least
+    alias :stub_through :stub_at_least
+
+  private
+    #   @param [Fixnum]
+    #   @param [true, false]
+    #   @return [String]
+    def rev_stub_words(max_words, save_pos=false)
+      str = self.reverse
+      str.scanner.pos = 0 - scanner.pos if save_pos
+
+      stub = str.stub_words(max_words, save_pos).reverse!
+      scanner.pos = 0 - str.scanner.pos
+      return stub
+    end
+
+    #   @param [Fixnum]
+    #   @param [true, false]
+    #   @return [String]
+    def rev_stub_at_most(max_chars, save_pos=false)
+      str = self.reverse
+      str.scanner.pos = 0 - scanner.pos if save_pos
+
+      stub = str.stub_at_most(max_chars, save_pos).reverse!
+      scanner.pos = 0 - str.scanner.pos
+      return stub
+    end
+
+    #   @param [Fixnum]
+    #   @param [true, false]
+    #   @return [String]
+    def rev_stub_at_least(min_chars, save_pos=false)
+      str = self.reverse
+      str.scanner.pos = 0 - scanner.pos if save_pos
+
+      stub = str.stub_at_least(min_chars, save_pos).reverse!
+      scanner.pos = 0 - str.scanner.pos
+      return stub
+    end
+  end
+end

data/lib/stubber/version.rb

@@ -0,0 +1,3 @@
+module Stubber
+  VERSION = '0.1.1'
+end

data/spec/quality_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+IGNORE = /\.(gitmodules|png$|tar$|gz$|rbc$|gem$|pdf$)/
+
+describe "The application itself" do
+  it "has no malformed whitespace" do
+    files = `git ls-files`.split("\n").select {|fn| fn !~ IGNORE}
+
+    files.should be_well_formed
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+require 'stubber'
+
+Dir[ Bundler.root.join("spec/support/**/*.rb") ].each{|f| require f}
+
+RSpec.configure do |c|
+  c.include CustomMatchers
+end

data/spec/string_stubber/base_spec.rb

@@ -0,0 +1,150 @@
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+describe Stubber::Base do
+  describe 'The Base module should behave like a proper mix-in ;)' do
+    before :each do
+      @methods = [ :stub_words, :stub_text, :scan_word, :scan_words, :scan_text ]
+    end
+
+    it 'should have class methods available' do
+      class TestMixin
+        extend Stubber::Base
+      end
+
+      @methods.each {|method|
+        TestMixin.respond_to?(method).should  be_true
+      }
+    end
+  end # Should be a Mix-In
+
+  describe 'The stubbing methods should behave as documented' do
+    before :each do
+      @text =  "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vivamus vitae risus vitae lorem iaculis placerat. "
+      @text << "Aliquam sit amet felis. Etiam congue. Donec risus risus, pretium ac, tincidunt eu, tempor eu, quam. Morbi "
+      @text << "blandit mollis magna. Suspendisse eu tortor. Donec vitae felis nec ligula blandit rhoncus. Ut a pede ac neque "
+      @text << "mattis facilisis. Nulla nunc ipsum, sodales vitae, hendrerit non, imperdiet ac, ante. Morbi sit amet mi. Ut "
+      @text << "magna. Curabitur id est. Nulla velit. Sed consectetuer sodales justo. Aliquam dictum gravida libero. Sed eu "
+      @text << "turpis. Nunc id lorem. Aenean consequat tempor mi. Phasellus in neque. Nunc fermentum convallis ligula."
+
+      @count = @text.split(/\W+/).count
+    end
+
+    describe 'Methods: stub_words, scan_words' do
+      it 'should return the expected number of words' do
+        Stubber.stub_words(@text, 10).split(/\W+/).count.should  be(10)
+      end
+
+      it 'should always return a string' do
+        stubs = [
+          Stubber.stub_words(@text,  -100),
+          Stubber.stub_words(@text,    -1),
+          Stubber.stub_words(@text,     0),
+          Stubber.stub_words(@text,    10),
+          Stubber.stub_words(@text,   100)
+        ]
+
+        stubs.each {|stub|
+          stub.is_a?(String).should be_true
+        }
+      end
+
+      it 'should never have trailing spaces' do
+        @count.times {|x|
+          (Stubber.stub_words(@text, x) !~ /\s+[\s\W]+$/).should be_true
+        }
+      end
+
+      it 'Should only have trailing non-words if they immediately follow words' do
+        # regex   = /[^\w\s]/
+        # scanner = StringScanner.new(@text)
+        # count   = @text.split(/[^\w\s]/).count
+        # puncts  = Hash[ count.times.map {
+        #                   scanner.scan_until(regex)
+        #                   [scanner.pre_match.split.count, scanner.pos - 1]
+        #                 }
+        #           ]
+        # 
+        # @count.times {|x|
+        #   (Stubber.stub_words(@text, x) !~ /\s+$/).should be_true
+        # }
+      end
+
+      #
+    end # describe 'Method: stub_words'
+
+    describe 'Methods: stub_text, scan_text' do
+      it 'should return fewer chars than specified, if the offset is in the middle of a word' do
+        Stubber.stub_text(@text, 33).size.should be(28)
+      end
+
+      it 'should return the same number of chars specified, if the offset lands on a punctuation character' do
+        # This is a tough nut to crack. Eesh.
+        Stubber.stub_text(@text, 27).should       == "Lorem ipsum dolor sit amet, "
+        Stubber.stub_text(@text, 27).size.should  be(28)
+      end
+
+      it 'should return fewer chars than specified, if the position lands in white-space' do
+        (Stubber.stub_text(@text, 28).size == 28).should be_true
+      end
+
+      it 'should return the whole string, if the ammt of text exceeds the amount of actual text' do
+        Stubber.stub_text(@text, 2000).casecmp(@text).should be(0)
+      end
+
+      it 'should return a copy of the whole string, if the ammt of text exceeds the amount of actual text' do
+        (Stubber.stub_text(@text, 2000).object_id != @text.object_id).should be_true
+      end
+
+      it 'should always return a string' do
+        stubs = [
+          Stubber.stub_text(@text,  -2000),
+          Stubber.stub_text(@text,     -1),
+          Stubber.stub_text(@text,      0),
+          Stubber.stub_text(@text,     10),
+          Stubber.stub_text(@text,   2000)
+        ]
+
+        stubs.each {|stub|
+          stub.is_a?(String).should be_true
+        }
+      end
+    end # describe 'Method: stub_text'
+
+    describe 'Methods: scan_word' do
+      before :each do
+        #             #1   #2    #3   #4  #5       #6            #7      #8
+        @words = %w[Lorem ipsum dolor sit amet consectetuer adipiscing elit.]
+        @wjoin = @words.join(' ')
+      end
+
+      it 'should scan ahead exactly one word' do
+        ss = StringScanner.new(@wjoin)
+
+        x = 0
+        until Stubber.scan_word(ss).nil?
+          x += 1
+        end
+
+        x.should be(@words.count)
+      end
+
+      it 'should return the correct word' do
+        ss = StringScanner.new(@wjoin)
+        @words.each do |word|
+          Stubber.scan_word(ss).strip.should == word
+        end
+      end
+
+      it 'scan_word should return a string, unless there is no more to scan' do
+        ss  = StringScanner.new(@wjoin)
+        x   = 0
+
+        until (word = Stubber.scan_word(ss)).nil?
+          word.should be_instance_of(String)
+        end
+
+        word.should be_nil
+      end
+    end
+  end
+end

data/spec/string_stubber/core_ext_spec.rb

@@ -0,0 +1,109 @@
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+describe Stubber::CoreExt do
+  describe 'The CoreExt module should be mixed into String (via stubber.rb)' do
+    before :each do
+      @methods = [ :scanner, :stub_words, :stub_at_most, :stub_at_least ]
+    end
+
+    it 'should have class methods available' do
+      text = "it 'should have class methods available' <-- OMG META"
+
+      @methods.each do |method|
+        text.respond_to?(method).should be_true
+      end
+    end
+  end # Should be mixed into String
+
+  describe 'The stubbing methods should behave as documented' do
+    before :each do
+      @text   = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vivamus vitae risus vitae lorem iaculis placerat. "
+      @count  = @text.split(/\W+/).count
+    end
+
+    it 'should return a StringScanner instance, when calling String#scanner' do
+      @text.scanner.should be_instance_of(StringScanner)
+    end
+
+    it 'should act upon the String instance, itself' do
+      @text.scanner.string.should be(@text)
+    end
+
+    describe 'Method: stub_words' do
+      it 'should retain its position' do
+        @text.stub_words(1)
+        @text.scanner.pos.should be(5)
+      end
+
+      it 'should always return a string' do
+        @text.stub_words( -100).should be_instance_of(String)
+        @text.stub_words(  -10).should be_instance_of(String)
+        @text.stub_words(    0).should be_instance_of(String)
+        @text.stub_words(   10).should be_instance_of(String)
+        @text.stub_words(  100).should be_instance_of(String)
+      end
+
+      it 'should correctly act on negative offsets' do
+        @text.stub_words( -1).should       eql("placerat. ")
+        @text.stub_words(-10).should       eql("consectetuer adipiscing elit. Vivamus vitae risus vitae lorem iaculis placerat. ")
+        @text.stub_words( -1, true).should eql("amet, ")
+      end
+
+      it 'should never have trailing spaces'
+      it 'should return the expected number of words'
+    end
+
+    describe 'Method: stub_at_most' do
+      it 'should retain its position, relative to what was returned' do
+        @text.stub_at_most(3)
+        @text.scanner.pos.should be(0)
+
+        @text.stub_at_most(5)
+        @text.scanner.pos.should be(5)
+      end
+
+      it 'should always return a string' do
+        @text.stub_at_most( -100).should be_instance_of(String)
+        @text.stub_at_most(  -10).should be_instance_of(String)
+        @text.stub_at_most(    0).should be_instance_of(String)
+        @text.stub_at_most(   10).should be_instance_of(String)
+        @text.stub_at_most(  100).should be_instance_of(String)
+      end
+
+      it 'should correctly act on negative offsets' do
+      end
+      it 'should never have trailing spaces'
+    end
+
+    describe 'Method: stub_at_least' do
+      it 'should retain its position' do
+        @text.stub_at_least(3)
+        @text.scanner.pos.should be(5)
+
+        @text.stub_at_least(5)
+        @text.scanner.pos.should be(5)
+
+        @text.stub_at_least(6)
+        @text.scanner.pos.should be(11)
+
+        @text.stub_at_least(3)
+        @text.scanner.pos.should be(5)
+
+        @text.stub_at_least(4, true)
+        @text.scanner.pos.should be(11)
+      end
+
+      it 'should always return a string' do
+        @text.stub_at_least( -100).should be_instance_of(String)
+        @text.stub_at_least(  -10).should be_instance_of(String)
+        @text.stub_at_least(    0).should be_instance_of(String)
+        @text.stub_at_least(   10).should be_instance_of(String)
+        @text.stub_at_least(  100).should be_instance_of(String)
+      end
+
+      it 'should correctly act on negative offsets' do
+      end
+      it 'should never have trailing spaces'
+    end
+  end # Docs check
+end

data/spec/string_stubber/readme_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path("../spec_helper", File.dirname(__FILE__))
+
+# This Spec is to validate the stuff I put in the README
+#
+describe 'Stubber::Readme' do
+  it "shouldn't make me look bad" do
+    #
+    # str = Lorem::Base.new('paragraphs', 1).output
+    #
+    str = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vivamus vitae risus vitae lorem iaculis placerat."
+
+    str.stub_words(5).should        == "Lorem ipsum dolor sit amet"
+    str.stub_words(5, true).should  == ", consectetuer adipiscing elit. Vivamus vitae"
+    str.stub_to(70).should          == "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vivamus "
+    str.stub_to(70).size.should     be(66)
+    str.stub_thru(70).should        == "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vivamus vitae"
+    str.stub_thru(70).size.should   be(71)
+
+    # Now the negatives!
+    str.stub_words(-5).should       == "risus vitae lorem iaculis placerat."
+    str.stub_words(-5, true).should == "consectetuer adipiscing elit. Vivamus vitae "
+    str.stub_to(-45).should         == " vitae risus vitae lorem iaculis placerat."
+    str.stub_to(-45).size.should    be(42)
+#    str.stub_thru(-50)
+  end
+end

data/spec/support/custom_matchers.rb

@@ -0,0 +1,44 @@
+module CustomMatchers
+  class BeWellFormed
+    def matches?(files)
+      @errors = files.map {|filename|
+                  [
+                    check_for_tabs(filename),
+                    excessive_spacing(filename),
+                    newline_precedes_eof(filename)
+                  ]
+                }.flatten.compact
+
+      @errors.empty?
+    end
+
+    def failure_message_for_should
+      @errors.join("\n")
+    end
+
+  private
+    def check_for_tabs(filename)
+      bad_lines = File.readlines(filename).each_with_index.map do |line, line_no|
+                    line_no + 1 if line["\t"] and line !~ /^\s+#.*\s+\n$/
+                  end.flatten.compact
+
+      "#{filename} has tab characters on lines #{bad_lines.join(', ')}" if bad_lines.any?
+    end
+
+    def excessive_spacing(filename)
+      bad_lines = File.readlines(filename).each_with_index.map do |line, line_no|
+                    line_no + 1 if line =~ /\s+\n$/ and line !~ /^\s+#.*\s+\n$/
+                  end.flatten.compact
+
+      "#{filename} has spaces on the EOL on lines #{bad_lines.join(', ')}" if bad_lines.any?
+    end
+
+    def newline_precedes_eof(filename)
+      "#{filename} does not have a newline (\\n) before EOF" if File.read(filename) !~ /\n$/
+    end
+  end
+
+  def be_well_formed
+    BeWellFormed.new
+  end
+end

data/string_stubber.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "stubber/version"
+
+Gem::Specification.new do |s|
+  s.name        = "stubber"
+  s.version     = Stubber::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Scott Gonyea"]
+  s.email       = ["me@sgonyea.com"]
+  s.homepage    = "http://github.com/sgonyea/string_stubber"
+  s.summary     = %q{Allows you to truncate Strings, while preserving whole-words.}
+  s.description = %q{Stubber allows you to truncate Strings, while preserving whole-words.}
+
+  s.add_dependency 'yard', '~>0.6'
+
+  s.add_development_dependency 'rspec', '~>2.4'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: stubber
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Scott Gonyea
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-01 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.4"
+  type: :development
+  version_requirements: *id002
+description: Stubber allows you to truncate Strings, while preserving whole-words.
+email: 
+- me@sgonyea.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- lib/stubber.rb
+- lib/stubber/base.rb
+- lib/stubber/core_ext.rb
+- lib/stubber/version.rb
+- spec/quality_spec.rb
+- spec/spec_helper.rb
+- spec/string_stubber/base_spec.rb
+- spec/string_stubber/core_ext_spec.rb
+- spec/string_stubber/readme_spec.rb
+- spec/support/custom_matchers.rb
+- string_stubber.gemspec
+has_rdoc: true
+homepage: http://github.com/sgonyea/string_stubber
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.0
+signing_key: 
+specification_version: 3
+summary: Allows you to truncate Strings, while preserving whole-words.
+test_files: 
+- spec/quality_spec.rb
+- spec/spec_helper.rb
+- spec/string_stubber/base_spec.rb
+- spec/string_stubber/core_ext_spec.rb
+- spec/string_stubber/readme_spec.rb
+- spec/support/custom_matchers.rb