nano 0.8.1

data/lib/nano/string/to_b.rb

@@ -0,0 +1,28 @@
+
+class String
+
+  # Interpret common affirmative string meanings as true,
+  # otherwise false. Balnk sapce and case are ignored.
+  # The following strings that will return true:
+  #
+  #   <tt>true</tt>,<tt>yes</tt>,<tt>on</tt>,<tt>t</tt>,<tt>1</tt>,<tt>y</tt>,<tt>==</tt>
+  #
+  # Examples:
+  #
+  #   "true".to_b   #=> true
+  #   "yes".to_b    #=> true
+  #   "no".to_b     #=> false
+  #   "123".to_b    #=> false
+  #
+  def to_b
+    case self.downcase.strip
+    when 'true', 'yes', 'on', 't', '1', 'y', '=='
+      return true
+    when 'nil', 'null'
+      return nil
+    else
+      return false
+    end
+  end
+
+end

data/lib/nano/string/to_const.rb

@@ -0,0 +1,13 @@
+class String
+  # Get a constant by a given string name.
+  #
+  #   "Class".to_const   #=> Class
+  #
+  # Note this method is not as verstile as it should be,
+  # since it can not access contants relative to the current 
+  # execution context. But without a binding_of_caller that
+  # does not seem possible.
+  def to_const
+    split('::').inject(Object){ |namespace,name| namespace.const_get(name) }
+  end
+end

data/lib/nano/string/to_date.rb

@@ -0,0 +1,10 @@
+
+class String
+
+  def to_date
+    require 'date'
+    require 'parsedate'
+    ::Date::civil(*ParseDate.parsedate(self)[0..2])
+  end
+
+end

data/lib/nano/string/to_proc.rb

@@ -0,0 +1,26 @@
+
+class String
+
+  # Evaluates a String as a Proc.
+  #
+  #   xyp = "|x,y| x + y".to_proc
+  #   xyp.class      #=> Proc
+  #   xyp.call(1,2)  #=> 3
+  #
+  #--
+  # Note: Sure would be nice if this could
+  # grab the caller's context!
+  #++
+  def to_proc(context=nil)
+    if context
+      if context.kind_of?(Binding) or context.kind_of?(Proc)
+        Kernel.eval "proc { #{self} }", context
+      else context
+        context.instance_eval "proc { #{self} }"
+      end
+    else
+      Kernel.eval "proc { #{self} }"
+    end
+  end
+
+end

data/lib/nano/string/to_re.rb

@@ -0,0 +1,14 @@
+
+class String
+
+  # Turns a string into a regular expression.
+  # By default it will escape all characters.
+  # Use <tt>false</tt> argument to turn off escaping.
+  #
+  #   "[".to_re  #=> /\[/
+  #
+  def to_re(esc=true)
+    Regexp.new((esc ? Regexp.escape(self) : self))
+  end
+
+end

data/lib/nano/string/to_time.rb

@@ -0,0 +1,9 @@
+
+class String
+
+  def to_time
+    require 'time'
+    Time.parse(self)
+  end
+
+end

data/lib/nano/string/underscore.rb

@@ -0,0 +1,9 @@
+class String
+
+  # Underscore string based on camelcase characteristics.
+  #
+  def underscore #(camel_cased_word)
+    self.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+  end
+
+end

data/lib/nano/string/unix_crypt%21.rb

@@ -0,0 +1,8 @@
+require 'nano/string/unix_crypt'
+
+class String
+  # Common Unix cryptography in-place method.
+  def unix_crypt!
+    self.replace( unix_crypt )
+  end
+end

data/lib/nano/string/unix_crypt.rb

@@ -0,0 +1,8 @@
+require 'nano/string/%3A%3Arand_letter'
+
+class String
+  # Common Unix cryptography method.
+  def unix_crypt
+    self.crypt(String.rand_letter + String.rand_letter)
+  end
+end

data/lib/nano/string/unpack.rb

@@ -0,0 +1,16 @@
+
+class String
+
+  alias_method( :unpack_from_orgin, :unpack )
+  # Upack with offset. Extends #unpack to allow a string 
+  # to be unpacked starting at an offset position within it.
+  #
+  def unpack(format, offset=nil)
+    if offset.nil?
+      unpack_from_orgin(format)
+    else
+      self[offset..-1].unpack_from_orgin(format)
+    end
+  end
+
+end

data/lib/nano/string/unshift.rb

@@ -0,0 +1,7 @@
+class String
+
+  def unshift( str=' ' )
+    insert(0, str)
+  end
+
+end

data/lib/nano/string/upcase%3F.rb

@@ -0,0 +1,17 @@
+#--
+# Credit goes to Phil Tomson.
+#++
+
+class String
+
+  # Is the string upcase/uppercase?
+  #
+  #   "THIS".upcase?  #=> true
+  #   "This".upcase?  #=> false
+  #   "this".upcase?  #=> false
+  #
+  def upcase?
+    self.upcase == self
+  end
+
+end

data/lib/nano/string/uppercase%3F.rb

@@ -0,0 +1,11 @@
+#--
+# Credit goes to Phil Tomson.
+#++
+require 'nano/string/upcase%3F'
+
+class String
+
+  # Alias for #upcase? method.
+  alias_method( :uppercase?, :upcase? )
+
+end #class String

data/lib/nano/string/whitespace%3F.rb

@@ -0,0 +1,5 @@
+require 'nano/string/blank%3F'
+
+class String
+  alias_method :whitespace?, :blank?
+end

data/lib/nano/string/word_filter%21.rb

@@ -0,0 +1,22 @@
+
+class String
+
+  # In place version of #word_filter.
+  #
+  #   "a string".word_filter { |word| ... }
+  #
+  def word_filter! #:yield:
+    rest_of_string = self
+    wordfind = /(\w+)/
+    offset = 0
+    while wmatch = wordfind.match(rest_of_string)
+      word = wmatch[0]
+      range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
+      rest_of_string = wmatch.post_match
+      self[range] = yield( word ).to_s
+      offset = self.length - rest_of_string.length
+    end
+    self
+  end
+
+end

data/lib/nano/string/word_filter.rb

@@ -0,0 +1,14 @@
+require 'nano/string/word_filter%21'
+
+class String
+
+  # Filters out words from a string based on block test.
+  #
+  #   "a string".word_filter { |word| word =~ /^a/ }  #=> "string"
+  #
+  def word_filter( &blk )
+    s = self.dup
+    s.word_filter!( &blk )
+  end
+
+end

data/lib/nano/string/word_wrap%21.rb

@@ -0,0 +1,13 @@
+require 'nano/string/word_wrap'
+
+class String
+
+  # As with #word_wrap, but modifies the string in place.
+  #
+  def word_wrap!(max=80)
+    raise ArgumentError, "Wrap margin too low: #{n}" if max <= 2
+    #gsub!( Regexp.new( "(.{1,#{max-1}}\\w)\\b\\s*" ), "\\1\n")
+    gsub!( /(.{1,#{max-1}}\S)([ ]|\n)/, "\\1\n")
+  end
+
+end

data/lib/nano/string/word_wrap.rb

@@ -0,0 +1,21 @@
+require 'nano/string/word_wrap%21'
+
+class String
+
+  # Word wrap a string not exceeding max width.
+  #
+  #   puts "this is a test".word_wrap(4)
+  #
+  # _produces_
+  #
+  #   this
+  #   is a
+  #   test
+  #
+  def word_wrap(max=80)
+    c = dup
+    c.word_wrap!(max)
+    c
+  end
+
+end

data/lib/nano/string/words.rb

@@ -0,0 +1,12 @@
+
+class String
+
+  # Returns an array of characters.
+  #
+  #   "abc 123".words  #=> ["abc","123"]
+  #
+  def words
+    self.split(/[ ]+/)
+  end
+
+end

data/lib/nano/string_as_array.rb

@@ -0,0 +1,16 @@
+
+# :title: String as Character Array
+#
+# The ideas here is to have string be polymorphic
+# as an array of characters. While not 100%
+# it is nearly so (getting there).
+#
+#   "123".pop # => "12"
+#
+
+require 'nano/string/at'
+require 'nano/string/pop'
+require 'nano/string/push'
+require 'nano/string/shift'
+require 'nano/string/unshift'  # I hate this name
+require 'nano/string/slap'     # alias for it

data/lib/nano/symbol.rb

@@ -0,0 +1,12 @@
+require 'nano/symbol/camelcase'
+require 'nano/symbol/camelize'
+require 'nano/symbol/capitalized%3F'
+require 'nano/symbol/downcase%3F'
+require 'nano/symbol/not'
+require 'nano/symbol/pad'
+require 'nano/symbol/succ'
+require 'nano/symbol/to_const'
+require 'nano/symbol/to_proc'
+require 'nano/symbol/to_str'
+require 'nano/symbol/underscore'
+require 'nano/symbol/upcase%3F'

data/lib/nano/symbol/camelcase.rb

@@ -0,0 +1,21 @@
+
+require 'nano/string/camelcase'
+
+class Symbol
+
+  # Converts a symbol to camelcase. By default capitalization
+  # occurs on whitespace and underscores. By setting the first
+  # parameter to <tt>true</tt> the first character can also be
+  # captizlized. The second parameter can be assigned a valid
+  # Regualr Expression characeter set to determine which
+  # characters to match for capitalizing subsequent parts of
+  # the symbol.
+  #
+  #   :this_is_a_test.camelcase              #=> :ThisIsATest
+  #   :this_is_a_test.camelcase(false)       #=> :thisIsATest
+  #
+  def camelcase( *args )
+    self.to_s.camelcase( *args ).to_sym
+  end
+
+end

data/lib/nano/symbol/camelize.rb

@@ -0,0 +1,10 @@
+
+require 'nano/string/camelize'
+
+class Symbol
+
+  def camelize( *args )
+    self.to_s.camelize( *args ).to_sym
+  end
+
+end

data/lib/nano/symbol/capitalized%3F.rb

@@ -0,0 +1,10 @@
+
+require 'nano/string/capitalized%3F'
+
+class Symbol
+
+  def capitalized?
+    self.to_s.capitalized?
+  end
+
+end

data/lib/nano/symbol/downcase%3F.rb

@@ -0,0 +1,10 @@
+
+require 'nano/string/downcase%3F'
+
+class Symbol
+
+  def downcase?
+    self.to_s.downcase?
+  end
+
+end

data/lib/nano/symbol/not.rb

@@ -0,0 +1,16 @@
+
+class Symbol
+
+  def not?
+    self.to_s.slice(0,1) == '~'
+  end
+
+  def ~@
+    if self.to_s.slice(0,1) == '~'
+      :"#{self.to_s[1..-1]}"
+    else
+      :"~#{self}"
+    end
+  end
+
+end

data/lib/nano/symbol/pad.rb

@@ -0,0 +1,20 @@
+class Symbol
+
+  # Easily manipulate undercores on symbols.
+  #
+  #   :a.pad(2)         #=> :__a__
+  #   :__a__.pad(-1)    #=> :_a_
+  #
+  def pad(i=1)
+    return self if i == 0
+    s = self.to_s
+    if i > 0
+      return ( ('_'*i) + self.to_s + ('_'*i) ).to_sym
+    else
+      i *= -1
+      return s[i..-i-1].to_sym if s[0..i-1] == ('_'*i) and s[-i..-1] == ('_'*i)
+      return self
+    end
+  end
+
+end

data/lib/nano/symbol/succ.rb

@@ -0,0 +1,18 @@
+
+class Symbol
+
+  # Successor method for symobol. This simply converts
+  # the symbol to a string uses String#succ and then
+  # converts it back to a symbol.
+  #
+  #   :a.succ => :b
+  #
+  #--
+  # In the future I would like this to work more like
+  # a simple chracerter dial.
+  #++
+  def succ
+    self.to_s.succ.intern
+  end
+
+end