chars 0.1.1 → 0.1.2

data/History.txt

@@ -1,3 +1,15 @@
+=== 0.1.2 / 2009-09-21
+
+* Require Hoe >= 2.3.3.
+* Require YARD >= 0.2.3.5.
+* Require RSpec >= 1.2.8.
+* Added Chars.visibile and Chars::VISIBLE (thanks flatline).
+* Added CharSet#random_distinct_bytes, CharSet#random_distinct_chars,
+  and CharSet#random_distinct_string (thanks flatline).
+* Use 'hoe/signing' for signed RubyGems.
+* Moved to YARD based documentation.
+* All specs now pass on JRuby 1.3.1.
+
 === 0.1.1 / 2009-04-01
 
 * Renamed CharSet#=~ to CharSet#===.

data/README.txt

@@ -27,13 +27,16 @@ recognizing text and generating random text from specific character sets.
     '[', ']', '{', '}', '.', '?', '!', '@', '#', '$', '%', '^', '&', '*',
     '_', '+', '=', '|', '\\', '<', '>', '/')
   * Space (' ', '\f', '\n', '\r', '\t', '\v')
+  * Visible ('0' - '9', 'a' - 'z', 'A' - 'Z', '\'', '"', '`', ',',
+    ';', ':', '~', '-', '(', ')', '[', ']', '{', '}', '.', '?', '!', '@',
+    '#', '$', '%', '^', '&', '*', '_', '+', '=', '|', '\\', '<', '>', '/',)
   * Printable ('0' - '9', 'a' - 'z', 'A' - 'Z', ' ', '\'', '"', '`', ',',
     ';', ':', '~', '-', '(', ')', '[', ']', '{', '}', '.', '?', '!', '@',
     '#', '$', '%', '^', '&', '*', '_', '+', '=', '|', '\\', '<', '>', '/',
     '\f', '\n', '\r', '\t', '\v')
   * Control ('\x00' - '\x1f', '\x7f')
-  * ASCII ('\x00' - '\x7f')
-  * All ('\x00' - '\xff')
+  * Signed ASCII ('\x00' - '\x7f')
+  * ASCII ('\x00' - '\xff')
 
 == EXAMPLES:
 
@@ -60,9 +63,13 @@ recognizing text and generating random text from specific character sets.
 
 * Return a random Array of characters from the alpha-numeric character set:
 
-    Chars.alpha_numeric.random_array(10)
+    Chars.alpha_numeric.random_chars(10)
     # => ["Q", "N", "S", "4", "x", "z", "3", "M", "F", "F"]
 
+* Return a random Array of a random length of unique characters from the visible character set:
+    Chars.visible.random_distinct_chars(1..10)
+    # => ["S", "l", "o", "8", "'", "q"]
+
 * Return a random String from the set of all characters:
 
     Chars.all.random_string(10)

data/Rakefile

@@ -2,13 +2,23 @@
 
 require 'rubygems'
 require 'hoe'
+require 'hoe/signing'
 require './tasks/spec.rb'
-require './lib/chars/version.rb'
+require './tasks/yard.rb'
 
-Hoe.new('chars', Chars::VERSION) do |p|
-  p.rubyforge_name = 'chars'
-  p.developer('Postmodern','postmodern.mod3@gmail.com')
-  p.remote_rdoc_dir = '/'
+Hoe.spec('chars') do
+  self.rubyforge_name = 'chars'
+  self.developer('Postmodern','postmodern.mod3@gmail.com')
+  self.remote_rdoc_dir = '/'
+  self.extra_deps = [
+    ['yard', '>=0.2.3.5']
+  ]
+
+  self.extra_dev_deps = [
+    ['rspec', '>=1.2.8']
+  ]
+
+  self.spec_extras = {:has_rdoc => 'yard'}
 end
 
 # vim: syntax=Ruby

data/lib/chars/char_set.rb

@@ -4,7 +4,10 @@ module Chars
   class CharSet < SortedSet
 
     #
-    # Creates a new CharSet object with the given _chars_.
+    # Creates a new CharSet object.
+    #
+    # @param [Array<String, Integer, Range>] chars
+    #   The chars for the CharSet.
     #
     def initialize(*chars)
       super()
@@ -29,8 +32,14 @@ module Chars
     alias map_bytes map
 
     #
-    # Returns +true+ if the character set includes the specified _char_,
-    # returns +false+ otherwise.
+    # Determines if a character is contained within the character set.
+    #
+    # @param [String] char
+    #   The character to search for.
+    #
+    # @return [Boolean]
+    #   Specifies whether the character is contained within the
+    #   character set.
     #
     def include_char?(char)
       return false unless char.respond_to?(:each_byte)
@@ -41,67 +50,125 @@ module Chars
     end
 
     #
-    # Returns all the characters within the character set as Strings.
+    # The characters within the character set.
+    #
+    # @return [Array<String>]
+    #   All the characters within the character set.
     #
     def chars
       map { |b| b.chr }
     end
 
     #
-    # Iterates over every character within the character set, passing
-    # each to the given _block_.
+    # Iterates over every character within the character set.
+    #
+    # @yield [char]
+    #   If a block is given, it will be passed each character in the
+    #   character set.
+    #
+    # @yieldparam [String] char
+    #   Each character in the character set.
     #
     def each_char(&block)
       each { |b| block.call(b.chr) } if block
     end
 
     #
-    # Selects an Array of characters from the character set that match
-    # the given _block_.
+    # Selects characters from the character set.
+    #
+    # @yield [char]
+    #   If a block is given, it will be used to select the characters
+    #   from the character set.
+    #
+    # @yieldparam [String] char
+    #   The character to select or reject.
+    #
+    # @return [Array<String>]
+    #   The selected characters from the character set.
     #
     def select_chars(&block)
       chars.select(&block)
     end
 
     #
-    # Maps the characters of the character set using the given _block_.
+    # Maps the characters of the character set.
+    #
+    # @yield [char]
+    #   The given block will be used to transform the characters within
+    #   the character set.
+    #
+    # @yieldparam [String] char
+    #   Each character in the character set.
+    #
+    # @return [Array<String>]
+    #   The mapped characters of the character set.
     #
     def map_chars(&block)
       chars.map(&block)
     end
 
     #
-    # Returns a random byte from the character set.
+    # @return [Integer]
+    #   A random byte from the character set.
     #
     def random_byte
       self.entries[rand(self.length)]
     end
 
     #
-    # Returns a random char from the character set.
+    # @return [String]
+    #   A random char from the character set.
     #
     def random_char
       random_byte.chr
     end
 
     #
-    # Pass a random byte to the specified _block_, _n_ times.
+    # Pass random bytes to a given block.
+    #
+    # @param [Integer] n
+    #   Specifies how many times to pass a random byte to the block.
+    #
+    # @yield [byte]
+    #   The block will receive the random bytes.
+    #
+    # @yieldparam [Integer] byte
+    #   The random byte from the character set.
+    #
+    # @return [Integer]
+    #   The number of times the given block was passed random bytes.
     #
     def each_random_byte(n,&block)
       n.times { block.call(random_byte) }
     end
 
     #
-    # Pass a random character to the specified _block_, _n_ times.
+    # Pass random characters to a given block.
+    #
+    # @param [Integer] n
+    #   Specifies how many times to pass a random character to the block.
+    #
+    # @yield [char]
+    #   The block will receive the random characters.
+    #
+    # @yieldparam [String] char
+    #   The random character from the character set.
+    #
+    # @return [Integer]
+    #   The number of times the given block was passed random characters.
     #
     def each_random_char(n,&block)
       each_random_byte(n) { |b| block.call(b.chr) }
     end
 
     #
-    # Returns an Array of the specified _length_ containing
-    # random bytes from the character set. The specified _length_ may
-    # be an Integer, Array or a Range of lengths.
+    # Creates an Array of random bytes from the character set.
+    #
+    # @param [Integer, Array, Range] length
+    #   The length of the Array of random bytes.
+    #
+    # @return [Array<Integer>]
+    #   The randomly selected bytes.
     #
     def random_bytes(length)
       if (length.kind_of?(Array) || length.kind_of?(Range))
@@ -112,35 +179,99 @@ module Chars
     end
 
     #
-    # Returns an Array of the specified _length_ containing
-    # random characters from the character set. The specified _length_
-    # may be an Integer, Array or a Range of lengths.
+    # Creates an Array of random non-repeating bytes from the character set.
+    #
+    # @param [Integer, Array, Range] length
+    #   The length of the Array of random non-repeating bytes.
+    #
+    # @return [Array<Integer>]
+    #   The randomly selected non-repeating bytes.
+    #
+    def random_distinct_bytes(length)
+      if (length.kind_of?(Array) || length.kind_of?(Range))
+        return self.entries.sort_by { rand }.slice(0...(length.sort_by { rand }.first))
+      else
+        return self.entries.sort_by { rand }.slice(0...length) 
+      end
+    end
+
+    #
+    # Creates an Array of random characters from the character set.
+    #
+    # @param [Integer, Array, Range] length
+    #   The length of the Array of random characters.
+    #
+    # @return [Array<String>]
+    #   The randomly selected characters.
     #
     def random_chars(length)
       random_bytes(length).map { |b| b.chr }
     end
 
     #
-    # Returns a String of the specified _length_ containing
-    # random characters from the character set.
+    # Creates a String containing randomly selected characters from the
+    # character set.
+    #
+    # @param [Integer, Array, Range] length
+    #   The length of the String of random characters.
+    #
+    # @return [String]
+    #   The String of randomly selected characters.
+    #
+    # @see random_chars
     #
     def random_string(length)
       random_chars(length).join
     end
 
     #
-    # Finds sub-strings within the specified _data_ that are part of the
-    # character set, using the given _options_.
+    # Creates an Array of random non-repeating characters from the
+    # character set.
+    #
+    # @param [Integer, Array, Range] length
+    #   The length of the Array of random non-repeating characters.
+    #
+    # @return [Array<Integer>]
+    #   The randomly selected non-repeating characters.
+    #
+    def random_distinct_chars(length)
+      random_distinct_bytes(length).map { |b| b.chr }
+    end
+
+    #
+    # Creates a String containing randomly selected non-repeating
+    # characters from the character set.
+    #
+    # @param [Integer, Array, Range] length
+    #   The length of the String of random non-repeating characters.
+    #
+    # @return [String]
+    #   The String of randomly selected non-repeating characters.
     #
-    # _options_ may contain the following keys:
-    # <tt>:length</tt>:: The minimum length of matching sub-strings
-    #                    within the _data_. Defaults to 4, if not
-    #                    specified.
-    # <tt>:offsets</tt>:: Specifies wether to return a Hash of the
-    #                     offsets within the _data_ and the matched
-    #                     sub-strings. If not specified a simple
-    #                     Array will be returned of the matched
-    #                     sub-strings.
+    # @see random_distinct_chars
+    #
+    def random_distinct_string(length)
+      random_distinct_chars(length).join
+    end
+
+
+    #
+    # Finds sub-strings within given data that are made of characters within
+    # the character set.
+    #
+    # @param [String] data
+    #   The data to find sub-strings within.
+    #
+    # @param [Hash] options
+    #   Additional options.
+    #
+    # @option options [Integer] :length (4)
+    #   The minimum length of sub-strings found within the given data.
+    #
+    # @option options [Boolean] :offsets (false)
+    #   Specifies whether to return a Hash of offsets and matched
+    #   sub-strings within the data, or to just return the matched
+    #   sub-strings themselves.
     #
     def strings_in(data,options={})
       min_length = (options[:length] || 4)
@@ -180,8 +311,14 @@ module Chars
     end
 
     #
-    # Creates a new CharSet object containing the both the characters
-    # of the character set and the specified _other_set_.
+    # Creates a new CharSet object by unioning the character set with
+    # another character set.
+    #
+    # @param [CharSet, Array, Range] other_set
+    #   The other character set to union with.
+    #
+    # @return [CharSet]
+    #   The unioned character sets.
     #
     def |(other_set)
       super(CharSet.new(other_set))
@@ -190,9 +327,17 @@ module Chars
     alias + |
 
     #
-    # Returns +true+ if all of the bytes within the specified _string_
-    # are included in the character set, returns +false+ otherwise.
+    # Compares the bytes within a given string with the bytes of the
+    # character set.
     #
+    # @param [String] string
+    #   The string to compare with the character set.
+    #
+    # @return [Boolean]
+    #   Specifies whether all of the bytes within the given string are
+    #   included in the character set.
+    #
+    # @example
     #   Chars.alpha === "hello"
     #   # => true
     #
@@ -211,6 +356,9 @@ module Chars
     #
     # Inspects the character set.
     #
+    # @return [String]
+    #   The inspected character set.
+    #
     def inspect
       "#<#{self.class.name}: {" + map { |b|
         case b

data/lib/chars/chars.rb

@@ -39,27 +39,38 @@ module Chars
   # The space character set
   SPACE = CharSet.new(' ', "\f", "\n", "\r", "\t", "\v")
 
+  # The set of printable characters (not including spaces)
+  VISIBLE = ALPHA_NUMERIC + ['\'', '"', '`', ',', ';', ':', '~', '-',
+            '(', ')', '[', ']', '{', '}', '.', '?', '!', '@', '#', '$',
+            '%', '^', '&', '*', '_', '+', '=', '|', '\\', '<', '>', '/']
+  
   # The set of printable characters (including spaces)
   PRINTABLE = ALPHA_NUMERIC + PUNCTUATION + SYMBOLS + SPACE
 
   # The control-char character set
   CONTROL = CharSet.new(0..0x1f, 0x7f)
 
-  # The ASCII character set
-  ASCII = CharSet.new(0..0x7f)
+  # The signed ASCII character set
+  SIGNED_ASCII = CharSet.new(0..0x7f)
 
   # The full 8-bit character set
-  ALL = CharSet.new(0..0xff)
+  ASCII = CharSet.new(0..0xff)
 
   #
-  # The numeric decimal character set.
+  # The decimal-digit character set.
+  #
+  # @return [CharSet]
+  #   The decimal-digit character set.
   #
   def Chars.numeric
     NUMERIC
   end
 
   #
-  # The octal character set.
+  # The octal-digit character set.
+  #
+  # @return [CharSet]
+  #   The octal-digit character set.
   #
   def Chars.octal
     OCTAL
@@ -68,6 +79,9 @@ module Chars
   #
   # The upper-case hexadecimal character set.
   #
+  # @return [CharSet]
+  #   The upper-case hexadecimal character set.
+  #
   def Chars.uppercase_hexadecimal
     UPPERCASE_HEXADECIMAL
   end
@@ -75,6 +89,9 @@ module Chars
   #
   # The lower-case hexadecimal character set.
   #
+  # @return [CharSet]
+  #   The lower-case hexadecimal character set.
+  #
   def Chars.lowercase_hexadecimal
     LOWERCASE_HEXADECIMAL
   end
@@ -82,26 +99,38 @@ module Chars
   #
   # The hexadecimal character set.
   #
+  # @return [CharSet]
+  #   The hexadecimal character set.
+  #
   def Chars.hexadecimal
     HEXADECIMAL
   end
 
   #
-  # The upper-case alpha character set.
+  # The upper-case alphabetic character set.
+  #
+  # @return [CharSet]
+  #   The upper-case alphabetic character set.
   #
   def Chars.uppercase_alpha
     UPPERCASE_ALPHA
   end
 
   #
-  # The lower-case alpha character set.
+  # The lower-case alphabetic character set.
+  #
+  # @return [CharSet]
+  #   The lower-case alphabetic character set.
   #
   def Chars.lowercase_alpha
     LOWERCASE_ALPHA
   end
 
   #
-  # The alpha character set.
+  # The alphabetic character set.
+  #
+  # @return [CharSet]
+  #   The alphabetic character set.
   #
   def Chars.alpha
     ALPHA
@@ -110,6 +139,9 @@ module Chars
   #
   # The alpha-numeric character set.
   #
+  # @return [CharSet]
+  #   The alpha-numeric character set.
+  #
   def Chars.alpha_numeric
     ALPHA_NUMERIC
   end
@@ -117,6 +149,9 @@ module Chars
   #
   # The punctuation character set.
   #
+  # @return [CharSet]
+  #   The punctuation character set.
+  #
   def Chars.punctuation
     PUNCTUATION
   end
@@ -124,42 +159,70 @@ module Chars
   #
   # The symbolic character set.
   #
+  # @return [CharSet]
+  #   The symbolic character set.
+  #
   def Chars.symbols
     SYMBOLS
   end
 
   #
-  # The space character set.
+  # The white-space character set.
+  #
+  # @return [CharSet]
+  #   The white-space character set.
   #
   def Chars.space
     SPACE
   end
 
+  #
+  # The set of printable characters, not including spaces.
+  #
+  # @return [CharSet]
+  #   The visible character set.
+  #
+  def Chars.visible
+    VISIBLE
+  end
+
   #
   # The set of printable characters, including spaces.
   #
+  # @return [CharSet]
+  #   The printable character set.
+  #
   def Chars.printable
     PRINTABLE
   end
 
   #
-  # The control-char character set.
+  # The control-character character set.
+  #
+  # @return [CharSet]
+  #   The control-character character set.
   #
   def Chars.control
     CONTROL
   end
 
   #
-  # The ASCII character set.
+  # The signed ASCII character set.
   #
-  def Chars.ascii
-    ASCII
+  # @return [CharSet]
+  #   The signed ASCII character set.
+  #
+  def Chars.signed_ascii
+    SIGNED_ASCII
   end
 
   #
-  # The full 8-bit character set.
+  # The ASCII character set.
+  #
+  # @return [CharSet]
+  #   The ASCII character set.
   #
-  def Chars.all
-    ALL
+  def Chars.ascii
+    ASCII
   end
 end

data/lib/chars/extensions/integer.rb

@@ -2,62 +2,215 @@ require 'chars/chars'
 
 class Integer
 
+  #
+  # Determines if the byte belongs to the decimal-digit character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the decimal-digit character set.
+  #
+  # @see Chars.numeric
+  #
   def numeric?
     Chars::NUMERIC.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the octal-digit character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the octal-digit character set.
+  #
+  # @see Chars.octal
+  #
   def octal?
     Chars::OCTAL.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the upper-case hexadecimal character
+  # set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the upper-case hexadecimal
+  #   character set.
+  #
+  # @see Chars.uppercase_hexadecimal
+  #
   def uppercase_hex?
     Chars::UPPERCASE_HEXADECIMAL.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the lower-case hexadecimal character
+  # set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the lower-case hexadecimal
+  #   character set.
+  #
+  # @see Chars.lowercase_hexadecimal
+  #
   def lowercase_hex?
     Chars::LOWERCASE_HEXADECIMAL.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the hexadecimal character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the hexadecimal character set.
+  #
+  # @see Chars.hexadecimal
+  #
   def hex?
     Chars::HEXADECIMAL.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the upper-case alphabetic character
+  # set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the upper-case alphabetic
+  #   character set.
+  #
+  # @see Chars.uppercase_alpha
+  #
   def uppercase_alpha?
     Chars::UPPERCASE_ALPHA.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the lower-case alphabetic character
+  # set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the lower-case alphabetic
+  #   character set.
+  #
+  # @see Chars.lowercase_alpha
+  #
   def lowercase_alpha?
     Chars::LOWERCASE_ALPHA.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the alphabetic character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the alphabetic character set.
+  #
+  # @see Chars.alpha
+  #
   def alpha?
     Chars::ALPHA.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the alpha-numeric character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the alpha-numeric character set.
+  #
+  # @see Chars.alpha_numeric
+  #
   def alpha_numeric?
     Chars::ALPHA_NUMERIC.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the punctuation character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the punctuation character set.
+  #
+  # @see Chars.punctuation
+  #
   def punctuation?
     Chars::PUNCTUATION.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the symbolic character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the symbolic character set.
+  #
+  # @see Chars.symbols
+  #
   def symbolic?
     Chars::SYMBOLS.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the white-space character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the white-space character set.
+  #
+  # @see Chars.space
+  #
   def space?
     Chars::SPACE.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the visible character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the visible character set.
+  #
+  # @see Chars.visible
+  #
+  def visible?
+    Chars::VISIBLE.include?(self)
+  end
+
+  #
+  # Determines if the byte belongs to the printable character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the printable character set.
+  #
+  # @see Chars.printable
+  #
   def printable?
     Chars::PRINTABLE.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the control-character character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the control-character character
+  #   set.
+  #
+  # @see Chars.control
+  #
   def control?
     Chars::CONTROL.include?(self)
   end
 
+  #
+  # Determines if the byte belongs to the signed-ASCII character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the signed-ASCII character set.
+  #
+  # @see Chars.signed_ascii
+  #
+  def signed_ascii?
+    Chars::SIGNED_ASCII.include?(self)
+  end
+
+  #
+  # Determines if the byte belongs to the ASCII character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the byte belongs to the ASCII character set.
+  #
+  # @see Chars.ascii
+  #
   def ascii?
     Chars::ASCII.include?(self)
   end

data/lib/chars/extensions/string.rb

@@ -2,62 +2,221 @@ require 'chars/chars'
 
 class String
 
+  #
+  # Determines whether the String belongs to the decimal-digit character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the decimal-digit character
+  #   set.
+  #
+  # @see Chars.numeric
+  #
   def numeric?
     Chars::NUMERIC === self
   end
 
+  #
+  # Determines whether the String belongs to the octal-digit character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the octal-digit character
+  #   set.
+  #
+  # @see Chars.octal
+  #
   def octal?
     Chars::OCTAL === self
   end
 
+  #
+  # Determines whether the String belongs to the upper-case hexadecimal
+  # character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the upper-case hexadecimal
+  #   character set.
+  #
+  # @see Chars.uppercase_hexadecimal
+  #
   def uppercase_hex?
     Chars::UPPERCASE_HEXADECIMAL === self
   end
 
+  #
+  # Determines whether the String belongs to the lower-case hexadecimal
+  # character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the lower-case hexadecimal
+  #   character set.
+  #
+  # @see Chars.lowercase_hexadecimal
+  #
   def lowercase_hex?
     Chars::LOWERCASE_HEXADECIMAL === self
   end
 
+  #
+  # Determines whether the String belongs to the hexadecimal character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the hexadecimal character set.
+  #
+  # @see Chars.hexadecimal
+  #
   def hex?
     Chars::HEXADECIMAL === self
   end
 
+  #
+  # Determines whether the String belongs to the upper-case alphabetic
+  # character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the upper-case alphabetic
+  #   character set.
+  #
+  # @see Chars.uppercase_alpha
+  #
   def uppercase_alpha?
     Chars::UPPERCASE_ALPHA === self
   end
 
+  #
+  # Determines whether the String belongs to the lower-case alphabetic
+  # character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the lower-case alphabetic
+  #   character set.
+  #
+  # @see Chars.lowercase_alpha
+  #
   def lowercase_alpha?
     Chars::LOWERCASE_ALPHA === self
   end
 
+  #
+  # Determines whether the String belongs to the alphabetic character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the alphabetic character set.
+  #
+  # @see Chars.alpha
+  #
   def alpha?
     Chars::ALPHA === self
   end
 
+  #
+  # Determines whether the String belongs to the alpha-numeric character
+  # set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the alpha-numeric character
+  #   set.
+  #
+  # @see Chars.alpha_numeric
+  #
   def alpha_numeric?
     Chars::ALPHA_NUMERIC === self
   end
 
+  #
+  # Determines whether the String belongs to the punctuation character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the punctuation character set.
+  #
+  # @see Chars.punctuation
+  #
   def punctuation?
     Chars::PUNCTUATION === self
   end
 
+  #
+  # Determines whether the String belongs to the symbolic character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the symbolic character set.
+  #
+  # @see Chars.symbols
+  #
   def symbolic?
     Chars::SYMBOLS === self
   end
 
+  #
+  # Determines whether the String belongs to the white-space character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the white-space character set.
+  #
+  # @see Chars.space
+  #
   def space?
     Chars::SPACE === self
   end
 
+  #
+  # Determines whether the String belongs to the visible character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the visible character set.
+  #
+  # @see Chars.visible
+  #
+  def visible?
+    Chars::VISIBLE === self
+  end
+
+  #
+  # Determines whether the String belongs to the printable character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the printable character set.
+  #
+  # @see Chars.printable
+  #
   def printable?
     Chars::PRINTABLE === self
   end
 
+  #
+  # Determines whether the String belongs to the control-character
+  # character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the control-character
+  #   character set.
+  #
+  # @see Chars.control
+  #
   def control?
     Chars::CONTROL === self
   end
 
+  #
+  # Determines whether the String belongs to the signed-ASCII character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the signed-ASCII character
+  #   set.
+  #
+  # @see Chars.signed_ascii
+  #
+  def signed_ascii?
+    Chars::SIGNED_ASCII === self
+  end
+
+  #
+  # Determines whether the String belongs to the ASCII character set.
+  #
+  # @return [Boolean]
+  #   Specifies whether the String belongs to the ASCII character set.
+  #
+  # @see Chars.ascii
+  #
   def ascii?
     Chars::ASCII === self
   end

data/lib/chars/version.rb

@@ -1,4 +1,4 @@
 module Chars
   # Chars version
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/spec/char_set_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Chars::CharSet do
   before(:all) do
     @integer_range = (0x41..0x43)
-    @string_range = ('A'..'C')
+    @string_range = ('A'..'Z')
     @integers = @integer_range.to_a
     @strings = @string_range.to_a
 
@@ -148,17 +148,51 @@ describe Chars::CharSet do
       @char_set.include?(b).should == true
     end
   end
+  
+  it "should return a random Array of unique bytes" do
+    bytes = @char_set.random_distinct_bytes(10)
+    bytes.uniq.length.should == bytes.length
+    bytes.each do |b|
+      @char_set.include?(b).should == true
+    end
+  end
+
+  it "should return a random Array of unique chars" do
+    chars = @char_set.random_distinct_chars(10)
+    chars.uniq.length.should == chars.length
+    chars.each do |c|
+      @char_set.include_char?(c).should == true
+    end
+  end
+
+  it "should return a random Array of unique bytes with a varying length" do
+    bytes = @char_set.random_distinct_bytes(5..10)
+    bytes.uniq.length.should == bytes.length
+    bytes.length.between?(5, 10).should == true
+    bytes.each do |b|
+      @char_set.include?(b).should == true
+    end
+  end
+
+  it "should return a random Array of unique chars with a varying length" do
+    chars = @char_set.random_distinct_chars(5..10)
+    chars.uniq.length.should == chars.length
+    chars.length.between?(5, 10).should == true
+    chars.each do |c|
+      @char_set.include_char?(c).should == true
+    end
+  end
+
 
   it "should be able to be compared with another set of chars" do
-    (@char_set == Chars::CharSet['A', 'B', 'C']).should == true
-    (@char_set == Chars::CharSet['A', 'C', 'B']).should == true
+    (@char_set == Chars::CharSet[('A'..'Z')]).should == true
   end
 
   it "should be able to be unioned with another set of chars" do
     super_set = (@char_set | Chars::CharSet['D'])
 
     super_set.class.should == Chars::CharSet
-    super_set.should == Chars::CharSet['A', 'B', 'C', 'D']
+    super_set.should == Chars::CharSet[('A'..'Z'), 'D']
   end
 
   it "should be able to be removed from another set of chars" do
@@ -173,7 +207,7 @@ describe Chars::CharSet do
   end
 
   it "should find sub-strings from a String belonging to the char set" do
-    @char_set.strings_in("AAAAXBXCCCCCC").should == [
+    @char_set.strings_in("AAAA!B!CCCCCC").should == [
       "AAAA",
       "CCCCCC"
     ]
@@ -181,6 +215,6 @@ describe Chars::CharSet do
 
   it "should determine if a String is made up of the characters from the char set" do
     (@char_set === "AABCBAA").should == true
-    (@char_set === "AADDEE").should_not == true
+    (@char_set === "AA!!EE").should_not == true
   end
 end

data/spec/chars_spec.rb

@@ -17,8 +17,9 @@ describe Chars do
     @punctuation_string = Chars.punctuation.random_string(10)
     @symbols_string = Chars.symbols.random_string(10)
     @control_string = Chars.control.random_string(10)
+    @signed_ascii_string = Chars.signed_ascii.random_string(10)
     @ascii_string = Chars.ascii.random_string(10)
-    @all_string = Chars.all.random_string(10)
+    @visible_string = Chars.visible.random_string(10)
   end
 
   it "should provide a numeric CharSet" do
@@ -83,6 +84,13 @@ describe Chars do
       Chars::ALPHA_NUMERIC.include?(b).should == true
     end
   end
+  
+  it "should provide a visible CharSet" do
+    @visible_string.length.should == 10
+    @visible_string.each_byte do |b|
+      Chars::VISIBLE.include?(b).should == true
+    end
+  end
 
   it "should provide a space CharSet" do
     @space_string.length.should == 10

data/spec/integer_spec.rb

@@ -51,6 +51,11 @@ describe Integer do
     0x20.should be_space
   end
 
+  it "should recognize visible bytes" do
+    0x41.should be_visible
+    0x20.should_not be_visible
+  end
+
   it "should recognize printable bytes" do
     0x3f.should be_printable
   end
@@ -59,7 +64,11 @@ describe Integer do
     0x1b.should be_control
   end
 
+  it "should recognize signed ASCII bytes" do
+    0x00.should be_signed_ascii
+  end
+
   it "should recognize ASCII bytes" do
-    0x00.should be_ascii
+    0x80.should be_ascii
   end
 end

data/spec/string_spec.rb

@@ -51,6 +51,11 @@ describe String do
     "  \t".should be_space
   end
 
+  it "should recognize visible strings" do
+    "abc".should be_visible
+    "ab c".should_not be_visible
+  end
+
   it "should recognize printable strings" do
     "abc, [123]\nDEF".should be_printable
   end
@@ -59,7 +64,11 @@ describe String do
     "\b\b\a".should be_control
   end
 
+  it "should recognize signed ASCII strings" do
+    "lol\0".should be_signed_ascii
+  end
+
   it "should recognize ASCII strings" do
-    "lol\0".should be_ascii
+    "\xff\xfe".should be_ascii
   end
 end

data/tasks/spec.rb

@@ -6,4 +6,5 @@ Spec::Rake::SpecTask.new(:spec) do |t|
   t.spec_opts = ['--colour', '--format', 'specdoc']
 end
 
+task :test => :spec
 task :default => :spec

metadata

@@ -1,17 +1,58 @@
 --- !ruby/object:Gem::Specification 
 name: chars
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Postmodern
 autorequire: 
 bindir: bin
-cert_chain: []
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDQDCCAiigAwIBAgIBADANBgkqhkiG9w0BAQUFADBGMRgwFgYDVQQDDA9wb3N0
+  bW9kZXJuLm1vZDMxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixk
+  ARkWA2NvbTAeFw0wOTA2MDMwNDU5MDNaFw0xMDA2MDMwNDU5MDNaMEYxGDAWBgNV
+  BAMMD3Bvc3Rtb2Rlcm4ubW9kMzEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYK
+  CZImiZPyLGQBGRYDY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA
+  1wvANkTDHFgVih5XLjuTwTZjgBq1lBGybXJiH6Id1lY2JOMqM5FB1DDHVvvij94i
+  mJabN0zkzu6VKWC70y0IwOxY7CPokr0eFdK/D0y7mCq1P8QITv76i2YqAl0eYqIt
+  W+IhIkANQ7E6uMZIZcdnfadC6lPAtlKkqtd9crvRbFgr6e3kyflmohbRnTEJHoRd
+  7SHHsybE6DSn7oTDs6XBTNrNIn5VfZA0z01eeos/+zBm1zKJOK2+/7xtLLDuDU9G
+  +Rd+ltUBbvxUrMNZmDG29pnmN2xTRH+Q8HxD2AxlvM5SRpK6OeZaHV7PaCCAVZ4L
+  T9BFl1sfMvRlABeGEkSyuQIDAQABozkwNzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIE
+  sDAdBgNVHQ4EFgQUKwsd+PqEYmBvyaTyoL+uRuk+PhEwDQYJKoZIhvcNAQEFBQAD
+  ggEBAB4TvHsrlbcXcKg6gX5BIb9tI+zGkpzo0Z7jnxMEcNO7NGGwmzafDBI/xZYv
+  xkRH3/HXbGGYDOi6Q6gWt5GujSx0bOImDtYTJTH8jnzN92HzEK5WdScm1QpZKF1e
+  cezArMbxbSPaosxTCtG6LQTkE28lFQsmFZ5xzouugS4h5+LVJiVMmiP+l3EfkjFa
+  GOURU+rNEMPWo8MCWivGW7jes6BMzWHcW7DQ0scNVmIcCIgdyMmpscuAEOSeghy9
+  /fFs57Ey2OXBL55nDOyvN/ZQ2Vab05UH4t+GCxjAPeirzL/29FBtePT6VD44c38j
+  pDj+ws7QjtH/Qcrr1l9jfN0ehDs=
+  -----END CERTIFICATE-----
 
-date: 2009-04-12 00:00:00 -07:00
+date: 2009-09-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.3.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.8
+    version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
   type: :development
@@ -20,9 +61,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.12.1
+        version: 2.3.3
     version: 
-description: Chars is a Ruby library for working with various character sets, recognizing text and generating random text from specific character sets.
+description: |-
+  Chars is a Ruby library for working with various character sets,
+  recognizing text and generating random text from specific character sets.
 email: 
 - postmodern.mod3@gmail.com
 executables: []
@@ -53,8 +96,10 @@ files:
 - spec/chars_spec.rb
 - spec/integer_spec.rb
 - spec/string_spec.rb
-has_rdoc: true
+has_rdoc: yard
 homepage: http://chars.rubyforge.org/
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -76,9 +121,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: chars
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Chars is a Ruby library for working with various character sets, recognizing text and generating random text from specific character sets.
 test_files: []
 

metadata.gz.sig

@@ -0,0 +1,4 @@
+m��8��‰�؈���&���I�Ҏܸ�g�I�i�:��w�ٓ�FJTn��:��gY��e���9������t��G�vh
F(I�(���q���P�I�2�.
ʶ(���M
+�
+��
+;��`��!�2��g6k�d=t���z���W���?�]�XԀ��$�{X&��_�"}��$:֭����$��$�w�V��&��yqc{�,j�Ӝ���C�w����