string_stubber 0.0.3 → 0.0.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    string_stubber (0.0.3)
+    string_stubber (0.0.5)
       yard (~> 0.6)
 
 GEM

data/lib/string_stubber/base.rb

@@ -1,6 +1,6 @@
 module StringStubber
   module Base
-    WORD = /[\w[:punct:]]+/
+    WORD = /(\w+[[:punct:]]*)+/
     SNIP = /\s+$/
 
     # Stubs a given text string, up to a given number of words
@@ -23,22 +23,35 @@ module StringStubber
       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)
-      max_words.times.map {
-        scanner.scan_until(WORD)
-      }.compact.join
+      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 || scanner.scan_until(WORD).nil?; end
+      until scanner.pos >= max_text || scan_word(scanner).nil?; end
 
-      (str = scanner.pre_match || scanner.string[start, max_text]).gsub!(SNIP, '')
+      (scanner.pre_match || scanner.string[start, max_text]).to_s.gsub(SNIP, '')
     end
   end # module Base
 end # module StringStubber

data/lib/string_stubber/core_ext.rb

@@ -2,10 +2,14 @@ module StringStubber
   module CoreExt
     include StringStubber::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
 
@@ -18,53 +22,84 @@ module StringStubber
     alias :stub   :stub_words
     alias :words  :stub_words
 
-    def stub_at_most(max_chars, save_pos=true)
+    #   @param [Fixnum]
+    #   @param [true, false]
+    #   @return [String]
+    def stub_at_most(max_chars, save_pos=false)
       scanner.reset unless save_pos
 
-      if max_chars < 0
-        rev_stub_at_most(max_chars.abs, save_pos)
-      else
-        scan_text(scanner, max_chars)
-      end
+      str = if max_chars < 0
+              rev_stub_at_most(max_chars.abs, save_pos)
+            else
+              scan_text(scanner, max_chars)
+            end
+
+      scanner.unscan if str.empty? && scanner.pos > max_chars
+
+      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
 
-    def stub_at_least(min_chars, save_pos=true)
+    #   @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
-        rev_stub_at_least(min_chars.abs, save_pos)
-      else
-        scan_text(scanner, min_chars) << scan_word(scanner).to_s
+        return rev_stub_at_least(min_chars.abs, save_pos)
       end
+
+      start = scanner.pos
+      str   = scan_text(scanner, min_chars)
+
+      if((scanner.pos - start) < min_chars)
+        str << scan_word(scanner).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
 
-      return str.stub_words(max_words, save_pos).reverse!
+      stub = str.stub_words(max_words, save_pos).reverse!
+      scanner.pos = 0 - str.scanner.pos
+      return stub
     end
 
-    def rev_stub_at_most(max_chars, save_pos=true)
+    #   @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
 
-      return str.stub_at_most(max_chars, save_pos).reverse!
+      stub = str.stub_at_most(max_chars, save_pos).reverse!
+      scanner.pos = 0 - str.scanner.pos
+      return stub
     end
 
-    def rev_stub_at_least(min_chars, save_pos=true)
+    #   @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
 
-      return str.stub_at_least(min_chars, save_pos).reverse!
+      stub = str.stub_at_least(min_chars, save_pos).reverse!
+      scanner.pos = 0 - str.scanner.pos
+      return stub
     end
   end
 end

data/lib/string_stubber/version.rb

@@ -1,3 +1,3 @@
 module StringStubber
-  VERSION = "0.0.3"
+  VERSION = '0.0.5'
 end

data/spec/string_stubber/base_spec.rb

@@ -17,7 +17,7 @@ describe StringStubber::Base do
     end
   end # Should be a Mix-In
 
-  describe 'The stubbing methods should behave as expected (Docs check)' do
+  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 "
@@ -29,7 +29,7 @@ describe StringStubber::Base do
       @count = @text.split(/\W+/).count
     end
 
-    describe 'Method: stub_words' do
+    describe 'Methods: stub_words, scan_words' do
       it 'should return the expected number of words' do
         StringStubber.stub_words(@text, 10).split(/\W+/).count.should  be(10)
       end
@@ -72,17 +72,77 @@ describe StringStubber::Base do
       #
     end # describe 'Method: stub_words'
 
-    describe 'Method: stub_text' do
-      it 'should return less than the number of chars specified, if the offset is in the middle of a word' do
+    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
         StringStubber.stub_text(@text, 33).size.should be(27)
       end
 
-      it 'should return less than the number of chars specified, if the offset is in the middle of a word\'s punctuation' do
-        StringStubber.stub_text(@text, 33).size.should be(27)
+      it 'should return the same number of chars specified, if the offset lands on a punctuation character' do
+        StringStubber.stub_text(@text, 27).size.should be(21)
+      end
+
+      it 'should return fewer chars than specified, if the position lands in white-space' do
+        (StringStubber.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
+        StringStubber.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
+        (StringStubber.stub_text(@text, 2000).object_id != @text.object_id).should be_true
       end
 
-      it 'should return exactly the number of chars specified, if the position lands on white-space' do
+      it 'should always return a string' do
+        stubs = [
+          StringStubber.stub_text(@text,  -2000),
+          StringStubber.stub_text(@text,     -1),
+          StringStubber.stub_text(@text,      0),
+          StringStubber.stub_text(@text,     10),
+          StringStubber.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 StringStubber.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|
+          StringStubber.scan_word(ss).strip.should eql(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 = StringStubber.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

@@ -1,2 +1,109 @@
 require File.expand_path("../spec_helper", File.dirname(__FILE__))
 
+describe StringStubber::CoreExt do
+  describe 'The CoreExt module should be mixed into String (via string_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, consectetuer adipiscing elit. Vivamus vitae risus vitae lorem iaculis placerat. ")
+      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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Scott Gonyea