webget-string_extensions 1.0.2 → 1.0.4

data/lib/string_extensions.rb

@@ -7,7 +7,6 @@
 #
 # Ruby String base class extensions
 #
-# For #prev and #pred see http://snippets.dzone.com/posts/show/2474
 ##
 
 class String
@@ -24,156 +23,87 @@ class String
   split(/\b/).map{|x| x.capitalize }.join
  end
 
+ # Increment the rightmost integer in a string, if any
+ #
+ # cf. String#succ
+ # cf. String#prev
+ def increment(step=1)
+  sub(/(.*)(\d+)/){|s| $1+((($2.to_i)+step).to_s) }    
+ end
 
-  # The opposite of String::next / String::succ. It is impossible to be a
-  # *complete* opposite because both "9".next = "10" and "09".next = "10";
-  # if going backwards from "10" there's no way to know whether the result
-  # should be "09" or "9". Where the first ranged character is about to
-  # underflow and the next character is within the same range the result
-  # is shrunk down - that is, "10" goes to "9", "aa" goes to "z"; any non-
-  # range prefix or suffix is OK, e.g. "+!$%10-=+" goes to "+!$%9-=+".
-  # Items in the middle of a string don't do this - e.g. "12.10" goes to
-  # "12.09", to match how "next" would work as best as possible.
-  #
-  # The standard "next" function works on strings that contain *no*
-  # alphanumeric characters, using character codes. This implementation
-  # of "prev" does *not* work on such strings - while strings may contain
-  # any characters you like, only the alphanumeric components are operated
-  # upon.
-  #
-  # Should total underflow result, "nil" will be returned - e.g. "00".prev
-  # returns 'nil', as does "a".prev. This is done even if there are other
-  # characters in the string that were not touched - e.g. "+0.0".prev
-  # also returns "nil". Broadly speaking, a "nil" return value is used for
-  # any attempt to find the previous value of a string that could not have
-  # been generated using "next" in the first place.
-  #
-  # As with "next" sometimes the result of "prev" can be a little obscure
-  # so it is often best to try out things using "irb" if unsure. Note in
-  # particular that software revision numbers do not necessarily behave
-  # predictably, because they don't with "next"! E.g. "12.4.9" might go to
-  # "12.4.10" for a revision number, but "12.4.9".next = "12.5.0". Thus
-  # "12.5.0".prev = "12.4.9" and "12.4.10".prev = "12.4.09" (because the
-  # only way to make "12.4.10" using "next" is to start at "12.4.09").
-  #
-  # Since 'succ' (successor) is an alias for 'next', so 'pred'
-  # (predecessor) is an alias for 'prev'.
-  #
-  def prev(collapse = false)
-    str        = self.dup
-    early_exit = false
-    any_done   = false
-    ranges     = [
-                   ('0'[0]..'9'[0]),
-                   ('a'[0]..'z'[0]),
-                   ('A'[0]..'Z'[0]),
-                   nil
-                 ]
-
-    # Search forward for the first in-range character. If found check
-    # to see if that character is "1", "a" or "A". If it is, record
-    # its index (from 0 to string length - 1). We'll need this if
-    # underflows wrap as far as the found byte because in that case
-    # this first found byte should be deleted ("aa..." -> "z...",
-    # "10..." -> "9...").
-
-    first_ranged = nil
-
-    for index in (1..str.length)
-      byte = str[index - 1]
-
-      # Determine whether or not the current byte is a number, lower case
-      # or upper case letter. We expect 'select' to only find one matching
-      # array entry in 'ranges', thus we dereference index 0 after the
-      # 'end' to put a matching range from within 'ranges' into 'within',
-      # or 'nil' for any unmatched byte.
-
-      within = ranges.select do |range|
-        range.nil? or range.include?(byte)
-      end [0]
-
-      unless within.nil?
-        case within.first
-          when '0'[0]
-            match_byte = '1'[0]
-          else
-            match_byte = within.first
-        end
-
-        first_ranged = index - 1 if (byte == match_byte)
-        first_within = within
-        break
-      end
-    end
-
-    for index in (1..str.length)
-
-      # Process the input string in reverse character order - fetch the
-      # bytes via negative index.
-
-      byte = str[-index]
-
-      within = ranges.select do |range|
-        range.nil? or range.include?(byte)
-      end [0]
-
-      # Skip this letter unless within a known range. Otherwise note that
-      # at least one byte was able to be processed.
-
-      next if within.nil?
-      any_done = true
-
-      # Decrement the current byte. If it is still within its range, set
-      # the byte and bail out - we're finished. Flag the early exit. If
-      # the byte is no longer within range, wrap ththe character around
-      # and continue the loop to carry the decrement to an earlier byte.
-
-      byte = byte - 1
-
-      if (within.include? byte)
-        str[-index] = byte
-        early_exit  = true
-        break
-      else
-        str[-index] = within.last
-
-        # If we've just wrapped around a character immediately after the
-        # one found right at the start ('0', 'a' or 'A') then this first
-        # ranged character should be deleted (so "10" -> "09"
-
-        if (first_ranged != nil and first_within.include?(byte + 1) and (first_ranged - str.length) == -(index + 1))
-          str.slice!(-(index + 1))
-          early_exit = true
-          break
-        end
-      end
-
-    end # From outer 'for' loop
+ # Decrement the rightmost integer in a string, if any
+ # 
+ # cf. String#succ
+ # cf. String#prev
+ def decrement(step=1)
+  sub(/(.*)(\d+)/){|s| $1+((($2.to_i)-step).to_s) }    
+ end
 
-    # If we did process at least one byte but we did not exit early, then
-    # the loop completed due to carrying a decrement to other bytes. This
-    # means an underflow condition - return 'nil'.
 
-    if (any_done == true and early_exit == false)
-      return nil
-    else
-      return str
-    end
+ # Return the previous character, with a changed flag and carry flag
+ #
+ # ==Examples
+ #   String.prev_char('n') => 'm', true, false   # change 
+ #   String.prev_char('a') => 'z', true, true    # change & carry
+ #   String.prev_char('6') => '5', true, false   # change
+ #   String.prev_char('0') => '9', true, true    # change & carry
+ #   String.prev_char('-') => '-', false, false  # unchanged
+
+ def self.prev_char(c) #=> prev_char, changed_flag, carry_flag
+  case c
+  when '1'..'9', 'B'..'Z', 'b'..'z'
+    return (c[0]-1).chr, true, false
+  when '0'
+    return '9', true, true
+  when 'A'
+    return 'Z', true, true
+  when 'a'
+    return 'z', true, true
+  else
+    return c, false, false
   end
+ end
+
+ # Return the previous string
+ #
+ #  c.f. String#next
+ #
+ # ==Examples
+ #   '888'.prev => '887'
+ #   'n'.prev => 'm'
+ #   'N'.prev => 'M'
+ #
+ # ==Examples with carry
+ #   '880'.prev => '879'
+ #   'nna'.prev => 'nmz'
+ #   'NNA'.prev => 'NMZ'
+ #   'nn0aA'.prev => 'nm9zZ'
+ 
+ def prev
+  self.clone.prev!
+ end
 
-  # As (extended) String::pred / String::prev, but modifies the string in
-  # place rather than returning a copy. If underflow occurs, the string
-  # will be unchanged. Returns 'self'.
-  #
-  def prev!
-    new_str = prev
-    self.replace(new_str) unless new_str.nil?
-    return self
+ # Do String#prev in place
+ def prev!
+  return self if length==0
+  i=length-1 # rightmost
+  while true do
+   c=self[i].chr
+   prev_c,changed_flag,carry_flag=String.prev_char(c)
+    return self if !changed_flag
+   self[i]=prev_c
+   return self if !carry_flag
+   i-=1
+   return nil if i<0
   end
+ end
 
-  alias pred  prev
-  alias pred! prev!
+ alias pred  prev   # String#pred : predecessor :: String#succ : successor
+ alias pred! prev!
 
+ class << self
+  alias_method :pred_char, :prev_char
+ end
 
 end
 

data/test/unit/string_extensions_test.rb

@@ -15,7 +15,44 @@ class StringExtensionsTest < Test::Unit::TestCase
   assert_equal("Foo Goo Hoo","foo goo hoo".capitalize_words)
  end
 
+ def test_increment
+  assert_equal('5','4'.increment,               'number is entire string')
+  assert_equal('foo5','foo4'.increment,         'number is rightmost')
+  assert_equal('5foo','4foo'.increment,         'number is leftmost')
+  assert_equal('foo5bar','foo4bar'.increment,   'number is in then middle')
+  assert_equal('foobar','foobar'.increment,     'no number, so should be unchanged')
+ end
+
+ def test_decrement
+  assert_equal('3','4'.decrement,               'number is entire string')
+  assert_equal('foo3','foo4'.decrement,         'number is rightmost')
+  assert_equal('3foo','4foo'.decrement,         'number is leftmost')
+  assert_equal('foo3bar','foo4bar'.decrement,   'number is in then middle')
+  assert_equal('foobar','foobar'.decrement,     'no number, so should be unchanged')
+ end
 
+ def test_prev_char
+  assert_equal(["-",false,false] ,String.prev_char("-"))  #unchanged
+  assert_equal(["5",true,false]  ,String.prev_char("6"))  #numeric typical
+  assert_equal(["9",true,true]   ,String.prev_char("0"))  #numeric carry
+  assert_equal(["m",true,false]  ,String.prev_char("n"))  #lowercase typical
+  assert_equal(["z",true,true]   ,String.prev_char("a"))  #lowercase carry
+  assert_equal(["M",true,false]  ,String.prev_char("N"))  #uppercase typical
+  assert_equal(["Z",true,true]   ,String.prev_char("A"))  #uppercase carry
+ end
+
+ def test_prev
+  assert_equal('n-','n-'.prev)     # unchanged
+  assert_equal('n5','n6'.prev)     # numeric typical
+  assert_equal('m9','n0'.prev)     # numeric carry
+  assert_equal('m999','n000'.prev) # numeric carries
+  assert_equal('ne','nf'.prev)     # lowercase typical
+  assert_equal('mz','na'.prev)     # lowercase carry
+  assert_equal('mzzz','naaa'.prev) # lowercase carries
+  assert_equal('NE','NF'.prev)     # uppercase typical
+  assert_equal('MZ','NA'.prev)     # uppercase carry
+  assert_equal('MZZZ','NAAA'.prev) # uppercase carries
+ end
 
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: webget-string_extensions
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
+  version: 1.0.4
 platform: ruby
 authors: 
 - WebGet
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-05 00:00:00 -08:00
+date: 2009-02-13 00:00:00 -08:00
 default_executable: 
 dependencies: []