chars 0.1.0

data/History.txt

@@ -0,0 +1,23 @@
+=== 0.1.0 / 2009-03-16
+
+* Initial release.
+* Provides character sets for:
+  * Numeric
+  * Octal
+  * Uppercase Hexadecimal
+  * Lowercase Hexadecimal
+  * Hexadecimal
+  * Uppercase Alpha
+  * Lowercase Alpha
+  * Alpha
+  * Alpha-numeric
+  * Punctuation
+  * Symbols
+  * Space
+  * Printable
+  * Control
+  * ASCII
+* Provides convenience methods for testing wether a String or Integer
+  belongs to a certain character set.
+* Supports random text generation using specific character sets.
+

data/Manifest.txt

@@ -0,0 +1,17 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/chars.rb
+lib/chars/char_set.rb
+lib/chars/chars.rb
+lib/chars/extensions.rb
+lib/chars/extensions/integer.rb
+lib/chars/extensions/string.rb
+lib/chars/version.rb
+tasks/spec.rb
+spec/spec_helper.rb
+spec/char_set_spec.rb
+spec/chars_spec.rb
+spec/integer_spec.rb
+spec/string_spec.rb

data/README.txt

@@ -0,0 +1,98 @@
+= Chars
+
+* http://chars.rubyforge.org/
+* http://github.com/postmodern/chars
+* Postmodern (postmodern.mod3 at gmail.com)
+
+== DESCRIPTION:
+
+Chars is a Ruby library for working with various character sets,
+recognizing text and generating random text from specific character sets.
+
+== FEATURES:
+
+* Provides character sets for:
+  * Numeric ('0' - '9')
+  * Octal ('0' - '7')
+  * Uppercase Hexadecimal ('0' - '9', 'A' - 'F')
+  * Lowercase Hexadecimal ('0' - '9', 'a' - 'f')
+  * Hexadecimal ('0' - '9', 'a' - 'f', 'A' - 'F')
+  * Uppercase Alpha ('A' - 'Z')
+  * Lowercase Alpha ('a' - 'z')
+  * Alpha ('a' - 'z', 'A' - 'Z')
+  * Alpha-numeric ('0' - '9', 'a' - 'z', 'A' - 'Z')
+  * Punctuation (' ', '\'', '"', '`', ',', ';', ':', '~', '-', '(', ')',
+    '[', ']', '{', '}', '.', '?', '!')
+  * Symbols (' ', '\'', '"', '`', ',', ';', ':', '~', '-', '(', ')',
+    '[', ']', '{', '}', '.', '?', '!', '@', '#', '$', '%', '^', '&', '*',
+    '_', '+', '=', '|', '\\', '<', '>', '/')
+  * Space (' ', '\f', '\n', '\r', '\t', '\v')
+  * Printable ('0' - '9', 'a' - 'z', 'A' - 'Z', ' ', '\'', '"', '`', ',',
+    ';', ':', '~', '-', '(', ')', '[', ']', '{', '}', '.', '?', '!', '@',
+    '#', '$', '%', '^', '&', '*', '_', '+', '=', '|', '\\', '<', '>', '/',
+    '\f', '\n', '\r', '\t', '\v')
+  * Control ('\x00' - '\x1f', '\x7f')
+  * ASCII ('\x00' - '\x7f')
+  * All ('\x00' - '\xff')
+
+== EXAMPLES:
+
+* Determine wether a byte belongs to a character set:
+
+    0x41.alpha?
+    # => true
+
+* Determine wether a String belongs to a character set:
+
+    "22e1c0".hex?
+    # => true
+
+* Return a random character from the set of all characters:
+
+    Chars.all.random_char
+    # => "\x94"
+
+* Return a random Array of characters from the alpha-numeric character set:
+
+    Chars.alpha_numeric.random_array(10)
+    # => ["Q", "N", "S", "4", "x", "z", "3", "M", "F", "F"]
+
+* Return a random String from the set of all characters:
+
+    Chars.all.random_string(10)
+    # => "\xc2h\xad\xccm7\x1e6J\x13"
+
+* Return a random String with a random length between 5 and 10, from the
+  set of space characters:
+
+    Chars.space.random_string(5..10)
+    # => "\r\v\n\t\n\f"
+
+== INSTALL:
+
+  $ sudo gem install chars
+
+== LICENSE:
+
+The MIT License
+
+Copyright (c) 2009 Hal Brodigan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,14 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './tasks/spec.rb'
+require './lib/chars/version.rb'
+
+Hoe.new('chars', Chars::VERSION) do |p|
+  p.rubyforge_name = 'chars'
+  p.developer('Postmodern','postmodern.mod3@gmail.com')
+  p.remote_rdoc_dir = '/'
+end
+
+# vim: syntax=Ruby

data/lib/chars.rb

@@ -0,0 +1,4 @@
+require 'chars/char_set'
+require 'chars/chars'
+require 'chars/extensions'
+require 'chars/version'

data/lib/chars/char_set.rb

@@ -0,0 +1,228 @@
+require 'set'
+
+module Chars
+  class CharSet < SortedSet
+
+    #
+    # Creates a new CharSet object with the given _chars_.
+    #
+    def initialize(*chars)
+      super()
+
+      merge_chars = lambda { |element|
+        if element.kind_of?(String)
+          element.each_byte(&merge_chars)
+        elsif element.kind_of?(Integer)
+          self << element
+        elsif element.kind_of?(Enumerable)
+          element.each(&merge_chars)
+        end
+      }
+
+      merge_chars.call(chars)
+    end
+
+    alias include_byte? include?
+    alias bytes to_a
+    alias each_byte each
+    alias select_bytes select
+    alias map_bytes map
+
+    #
+    # Returns +true+ if the character set includes the specified _char_,
+    # returns +false+ otherwise.
+    #
+    def include_char?(char)
+      return false unless char.respond_to?(:each_byte)
+
+      char.each_byte do |b|
+        return include?(b)
+      end
+    end
+
+    #
+    # Returns all the characters within the character set as Strings.
+    #
+    def chars
+      map { |b| b.chr }
+    end
+
+    #
+    # Iterates over every character within the character set, passing
+    # each to the given _block_.
+    #
+    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_.
+    #
+    def select_chars(&block)
+      chars.select(&block)
+    end
+
+    #
+    # Maps the characters of the character set using the given _block_.
+    #
+    def map_chars(&block)
+      chars.map(&block)
+    end
+
+    #
+    # Returns a random byte from the character set.
+    #
+    def random_byte
+      self.entries[rand(self.length)]
+    end
+
+    #
+    # Returns a random char from the character set.
+    #
+    def random_char
+      random_byte.chr
+    end
+
+    #
+    # Pass a random byte to the specified _block_, _n_ times.
+    #
+    def each_random_byte(n,&block)
+      n.times { block.call(random_byte) }
+    end
+
+    #
+    # Pass a random character to the specified _block_, _n_ times.
+    #
+    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.
+    #
+    def random_bytes(length)
+      if (length.kind_of?(Array) || length.kind_of?(Range))
+        return Array.new(length.sort_by { rand }.first) { random_byte }
+      else
+        return Array.new(length) { random_byte }
+      end
+    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.
+    #
+    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.
+    #
+    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_.
+    #
+    # _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.
+    #
+    def strings_in(data,options={})
+      min_length = (options[:length] || 4)
+
+      if options[:offsets]
+        found = {}
+        found_substring = lambda { |offset,substring|
+          found[offset] = substring
+        }
+      else
+        found = []
+        found_substring = lambda { |offset,substring|
+          found << substring
+        }
+      end
+
+      return found if data.length < min_length
+
+      index = 0
+
+      while index <= (data.length - min_length)
+        if self =~ data[index...(index + min_length)]
+          sub_index = (index + min_length)
+
+          while self.include_char?(data[sub_index..sub_index])
+            sub_index += 1
+          end
+
+          found_substring.call(index,data[index...sub_index])
+          index = sub_index
+        else
+          index += 1
+        end
+      end
+
+      return found
+    end
+
+    #
+    # Creates a new CharSet object containing the both the characters
+    # of the character set and the specified _other_set_.
+    #
+    def |(other_set)
+      super(CharSet.new(other_set))
+    end
+
+    alias + |
+
+      #
+      # Returns +true+ if all of the bytes within the specified _string_
+      # are included in the character set, returns +false+ otherwise.
+      #
+      #   Chars.alpha =~ "hello"
+      #   # => true
+      #
+      def =~(string)
+        return false unless string.respond_to?(:each_byte)
+
+        string.each_byte do |b|
+          return false unless include?(b)
+        end
+
+        return true
+      end
+
+    #
+    # Inspects the character set.
+    #
+    def inspect
+      "#<#{self.class.name}: {" + map { |b|
+        case b
+        when (0x07..0x0d), (0x20..0x7e)
+          b.chr.dump
+        when 0x00
+          # sly hack to make char-sets more friendly
+          # to us C programmers
+          '"\0"'
+        else
+          "0x%02x" % b
+        end
+      }.join(', ') + "}>"
+    end
+
+  end
+end

data/lib/chars/chars.rb

@@ -0,0 +1,165 @@
+require 'chars/char_set'
+
+module Chars
+  # The numeric decimal character set
+  NUMERIC = CharSet.new('0'..'9')
+
+  # The octal character set
+  OCTAL = CharSet.new('0'..'7')
+
+  # The upper-case hexadecimal character set
+  UPPERCASE_HEXADECIMAL = NUMERIC + ('A'..'F')
+
+  # The lower-case hexadecimal character set
+  LOWERCASE_HEXADECIMAL = NUMERIC + ('a'..'f')
+
+  # The hexadecimal character set
+  HEXADECIMAL = UPPERCASE_HEXADECIMAL + LOWERCASE_HEXADECIMAL
+
+  # The upper-case alpha character set
+  UPPERCASE_ALPHA = CharSet.new('A'..'Z')
+
+  # The lower-case alpha character set
+  LOWERCASE_ALPHA = CharSet.new('a'..'z')
+
+  # The alpha character set
+  ALPHA = UPPERCASE_ALPHA + LOWERCASE_ALPHA
+
+  # The alpha-numeric character set
+  ALPHA_NUMERIC = ALPHA + NUMERIC
+
+  # The punctuation character set
+  PUNCTUATION = CharSet.new(' ', '\'', '"', '`', ',', ';', ':', '~', '-',
+                            '(', ')', '[', ']', '{', '}', '.', '?', '!')
+
+  # The symbolic character set
+  SYMBOLS = PUNCTUATION + ['@', '#', '$', '%', '^', '&', '*', '_', '+',
+    '=', '|', '\\', '<', '>', '/']
+
+  # The space character set
+  SPACE = CharSet.new(' ', "\f", "\n", "\r", "\t", "\v")
+
+  # 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 full 8-bit character set
+  ALL = CharSet.new(0..0xff)
+
+  #
+  # The numeric decimal character set.
+  #
+  def Chars.numeric
+    NUMERIC
+  end
+
+  #
+  # The octal character set.
+  #
+  def Chars.octal
+    OCTAL
+  end
+
+  #
+  # The upper-case hexadecimal character set.
+  #
+  def Chars.uppercase_hexadecimal
+    UPPERCASE_HEXADECIMAL
+  end
+
+  #
+  # The lower-case hexadecimal character set.
+  #
+  def Chars.lowercase_hexadecimal
+    LOWERCASE_HEXADECIMAL
+  end
+
+  #
+  # The hexadecimal character set.
+  #
+  def Chars.hexadecimal
+    HEXADECIMAL
+  end
+
+  #
+  # The upper-case alpha character set.
+  #
+  def Chars.uppercase_alpha
+    UPPERCASE_ALPHA
+  end
+
+  #
+  # The lower-case alpha character set.
+  #
+  def Chars.lowercase_alpha
+    LOWERCASE_ALPHA
+  end
+
+  #
+  # The alpha character set.
+  #
+  def Chars.alpha
+    ALPHA
+  end
+
+  #
+  # The alpha-numeric character set.
+  #
+  def Chars.alpha_numeric
+    ALPHA_NUMERIC
+  end
+
+  #
+  # The punctuation character set.
+  #
+  def Chars.punctuation
+    PUNCTUATION
+  end
+
+  #
+  # The symbolic character set.
+  #
+  def Chars.symbols
+    SYMBOLS
+  end
+
+  #
+  # The space character set.
+  #
+  def Chars.space
+    SPACE
+  end
+
+  #
+  # The set of printable characters, including spaces.
+  #
+  def Chars.printable
+    PRINTABLE
+  end
+
+  #
+  # The control-char character set.
+  #
+  def Chars.control
+    CONTROL
+  end
+
+  #
+  # The ASCII character set.
+  #
+  def Chars.ascii
+    ASCII
+  end
+
+  #
+  # The full 8-bit character set.
+  #
+  def Chars.all
+    ALL
+  end
+end

data/lib/chars/extensions.rb

@@ -0,0 +1,2 @@
+require 'chars/extensions/integer'
+require 'chars/extensions/string'

data/lib/chars/extensions/integer.rb

@@ -0,0 +1,65 @@
+require 'chars/chars'
+
+class Integer
+
+  def numeric?
+    Chars::NUMERIC.include?(self)
+  end
+
+  def octal?
+    Chars::OCTAL.include?(self)
+  end
+
+  def uppercase_hex?
+    Chars::UPPERCASE_HEXADECIMAL.include?(self)
+  end
+
+  def lowercase_hex?
+    Chars::LOWERCASE_HEXADECIMAL.include?(self)
+  end
+
+  def hex?
+    Chars::HEXADECIMAL.include?(self)
+  end
+
+  def uppercase_alpha?
+    Chars::UPPERCASE_ALPHA.include?(self)
+  end
+
+  def lowercase_alpha?
+    Chars::LOWERCASE_ALPHA.include?(self)
+  end
+
+  def alpha?
+    Chars::ALPHA.include?(self)
+  end
+
+  def alpha_numeric?
+    Chars::ALPHA_NUMERIC.include?(self)
+  end
+
+  def punctuation?
+    Chars::PUNCTUATION.include?(self)
+  end
+
+  def symbolic?
+    Chars::SYMBOLS.include?(self)
+  end
+
+  def space?
+    Chars::SPACE.include?(self)
+  end
+
+  def printable?
+    Chars::PRINTABLE.include?(self)
+  end
+
+  def control?
+    Chars::CONTROL.include?(self)
+  end
+
+  def ascii?
+    Chars::ASCII.include?(self)
+  end
+
+end

data/lib/chars/extensions/string.rb

@@ -0,0 +1,65 @@
+require 'chars/chars'
+
+class String
+
+  def numeric?
+    Chars::NUMERIC =~ self
+  end
+
+  def octal?
+    Chars::OCTAL =~ self
+  end
+
+  def uppercase_hex?
+    Chars::UPPERCASE_HEXADECIMAL =~ self
+  end
+
+  def lowercase_hex?
+    Chars::LOWERCASE_HEXADECIMAL =~ self
+  end
+
+  def hex?
+    Chars::HEXADECIMAL =~ self
+  end
+
+  def uppercase_alpha?
+    Chars::UPPERCASE_ALPHA =~ self
+  end
+
+  def lowercase_alpha?
+    Chars::LOWERCASE_ALPHA =~ self
+  end
+
+  def alpha?
+    Chars::ALPHA =~ self
+  end
+
+  def alpha_numeric?
+    Chars::ALPHA_NUMERIC =~ self
+  end
+
+  def punctuation?
+    Chars::PUNCTUATION =~ self
+  end
+
+  def symbolic?
+    Chars::SYMBOLS =~ self
+  end
+
+  def space?
+    Chars::SPACE =~ self
+  end
+
+  def printable?
+    Chars::PRINTABLE =~ self
+  end
+
+  def control?
+    Chars::CONTROL =~ self
+  end
+
+  def ascii?
+    Chars::ASCII =~ self
+  end
+
+end

data/lib/chars/version.rb

@@ -0,0 +1,4 @@
+module Chars
+  # Chars version
+  VERSION = '0.1.0'
+end

data/spec/char_set_spec.rb

@@ -0,0 +1,186 @@
+require 'chars/chars'
+
+require 'spec_helper'
+
+describe Chars::CharSet do
+  before(:all) do
+    @integer_range = (0x41..0x43)
+    @string_range = ('A'..'C')
+    @integers = @integer_range.to_a
+    @strings = @string_range.to_a
+
+    @char_set = Chars::CharSet.new(*@strings)
+  end
+
+  it "may be created with String arguments" do
+    @chars = Chars::CharSet.new(*@strings)
+
+    @strings.each do |s|
+      @chars.include_char?(s).should == true
+    end
+  end
+
+  it "may be created with an Array of Strings" do
+    @chars = Chars::CharSet.new(@strings)
+
+    @strings.each do |s|
+      @chars.include_char?(s).should == true
+    end
+  end
+
+  it "may be created with a Range of Strings" do
+    @chars = Chars::CharSet.new(@string_range)
+
+    @strings.each do |s|
+      @chars.include_char?(s).should == true
+    end
+  end
+
+  it "may be created with Integer arguments" do
+    @chars = Chars::CharSet.new(*@integers)
+
+    @integers.each do |i|
+      @chars.include?(i).should == true
+    end
+  end
+
+  it "may be created with an Array of Integers" do
+    @chars = Chars::CharSet.new(@integers)
+
+    @integers.each do |i|
+      @chars.include?(i).should == true
+    end
+  end
+
+  it "may be created with a Range of Integers" do
+    @chars = Chars::CharSet.new(@integer_range)
+
+    @integers.each do |i|
+      @chars.include?(i).should == true
+    end
+  end
+
+  it "should include Strings" do
+    @char_set.include_char?('A').should == true
+  end
+
+  it "should include Integers" do
+    @char_set.include?(0x41).should == true
+  end
+
+  it "should be able to select bytes" do
+    @sub_chars = @char_set.select_bytes { |c| c <= 0x42 }
+
+    @sub_chars.should == [0x41, 0x42]
+  end
+
+  it "should be able to select chars" do
+    @sub_chars = @char_set.select_chars { |c| c <= 'B' }
+
+    @sub_chars.should == ['A', 'B']
+  end
+
+  it "should return a random byte" do
+    @char_set.include?(@char_set.random_byte).should == true
+  end
+
+  it "should return a random char" do
+    @char_set.include_char?(@char_set.random_char).should == true
+  end
+
+  it "should iterate over n random bytes" do
+    @char_set.each_random_byte(10) do |b|
+      @char_set.include?(b).should == true
+    end
+  end
+
+  it "should iterate over n random chars" do
+    @char_set.each_random_char(10) do |c|
+      @char_set.include_char?(c).should == true
+    end
+  end
+
+  it "should return a random Array of bytes" do
+    bytes = @char_set.random_bytes(10)
+
+    bytes.each do |b|
+      @char_set.include?(b).should == true
+    end
+  end
+
+  it "should return a random Array of chars" do
+    chars = @char_set.random_chars(10)
+
+    chars.each do |c|
+      @char_set.include_char?(c).should == true
+    end
+  end
+
+  it "should return a random Array of bytes with a varying length" do
+    bytes = @char_set.random_bytes(5..10)
+
+    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 chars with a varying length" do
+    chars = @char_set.random_chars(5..10)
+
+    chars.length.between?(5, 10).should == true
+    chars.each do |c|
+      @char_set.include_char?(c).should == true
+    end
+  end
+
+  it "should return a random String of chars" do
+    @char_set.random_string(10).each_byte do |b|
+      @char_set.include?(b).should == true
+    end
+  end
+
+  it "should return a random String of chars with a varying length" do
+    string = @char_set.random_string(5..10)
+
+    string.length.between?(5, 10)
+    string.each_byte do |b|
+      @char_set.include?(b).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
+  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']
+  end
+
+  it "should be able to be removed from another set of chars" do
+    sub_set = (@char_set - Chars::CharSet['B'])
+
+    sub_set.class.should == Chars::CharSet
+    sub_set.subset?(@char_set).should == true
+  end
+
+  it "should find one sub-string from a String belonging to the char set" do
+    @char_set.strings_in("AAAA").should == ["AAAA"]
+  end
+
+  it "should find sub-strings from a String belonging to the char set" do
+    @char_set.strings_in("AAAAXBXCCCCCC").should == [
+      "AAAA",
+      "CCCCCC"
+    ]
+  end
+
+  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
+  end
+end

data/spec/chars_spec.rb

@@ -0,0 +1,107 @@
+require 'chars/chars'
+
+require 'spec_helper'
+
+describe Chars do
+  before(:all) do
+    @numeric_string = Chars.numeric.random_string(10)
+    @octal_string = Chars.octal.random_string(10)
+    @uppercase_hex_string = Chars.uppercase_hexadecimal.random_string(10)
+    @lowercase_hex_string = Chars.lowercase_hexadecimal.random_string(10)
+    @hex_string = Chars.hexadecimal.random_string(10)
+    @uppercase_alpha_string = Chars.uppercase_alpha.random_string(10)
+    @lowercase_alpha_string = Chars.lowercase_alpha.random_string(10)
+    @alpha_string = Chars.alpha.random_string(10)
+    @alpha_numeric_string = Chars.alpha_numeric.random_string(10)
+    @space_string = Chars.space.random_string(10)
+    @punctuation_string = Chars.punctuation.random_string(10)
+    @symbols_string = Chars.symbols.random_string(10)
+    @control_string = Chars.control.random_string(10)
+    @ascii_string = Chars.ascii.random_string(10)
+    @all_string = Chars.all.random_string(10)
+  end
+
+  it "should provide a numeric CharSet" do
+    @numeric_string.length.should == 10
+    @numeric_string.each_byte do |b|
+      Chars::NUMERIC.include?(b).should == true
+    end
+  end
+
+  it "should provide an octal CharSet" do
+    @octal_string.length.should == 10
+    @octal_string.each_byte do |b|
+      Chars::OCTAL.include?(b).should == true
+    end
+  end
+
+  it "should provide an upper-case hexadecimal CharSet" do
+    @uppercase_hex_string.length.should == 10
+    @uppercase_hex_string.each_byte do |b|
+      Chars::UPPERCASE_HEXADECIMAL.include?(b).should == true
+    end
+  end
+
+  it "should provide a lower-case hexadecimal CharSet" do
+    @lowercase_hex_string.length.should == 10
+    @lowercase_hex_string.each_byte do |b|
+      Chars::LOWERCASE_HEXADECIMAL.include?(b).should == true
+    end
+  end
+
+  it "should provide a hexadecimal CharSet" do
+    @hex_string.length.should == 10
+    @hex_string.each_byte do |b|
+      Chars::HEXADECIMAL.include?(b).should == true
+    end
+  end
+
+  it "should provide an upper-case alpha CharSet" do
+    @uppercase_alpha_string.length.should == 10
+    @uppercase_alpha_string.each_byte do |b|
+      Chars::UPPERCASE_ALPHA.include?(b).should == true
+    end
+  end
+
+  it "should provide a lower-case alpha CharSet" do
+    @lowercase_alpha_string.length.should == 10
+    @lowercase_alpha_string.each_byte do |b|
+      Chars::LOWERCASE_ALPHA.include?(b).should == true
+    end
+  end
+
+  it "should provide an alpha CharSet" do
+    @alpha_string.length.should == 10
+    @alpha_string.each_byte do |b|
+      Chars::ALPHA.include?(b).should == true
+    end
+  end
+
+  it "should provide an alpha-numeric CharSet" do
+    @alpha_numeric_string.length.should == 10
+    @alpha_numeric_string.each_byte do |b|
+      Chars::ALPHA_NUMERIC.include?(b).should == true
+    end
+  end
+
+  it "should provide a space CharSet" do
+    @space_string.length.should == 10
+    @space_string.each_byte do |b|
+      Chars::SPACE.include?(b).should == true
+    end
+  end
+
+  it "should provide a punctuation CharSet" do
+    @punctuation_string.length.should == 10
+    @punctuation_string.each_byte do |b|
+      Chars::PUNCTUATION.include?(b).should == true
+    end
+  end
+
+  it "should provide a symbols CharSet" do
+    @symbols_string.length.should == 10
+    @symbols_string.each_byte do |b|
+      Chars::SYMBOLS.include?(b).should == true
+    end
+  end
+end

data/spec/integer_spec.rb

@@ -0,0 +1,65 @@
+require 'chars/extensions/integer'
+
+require 'spec_helper'
+
+describe Integer do
+  it "should recognize numeric bytes" do
+    0x39.should be_numeric
+  end
+
+  it "should recognize octal bytes" do
+    0x30.should be_octal
+  end
+
+  it "should recognize upper-case hexadecimal bytes" do
+    0x44.should be_uppercase_hex
+  end
+
+  it "should recognize lower-case hexadecimal bytes" do
+    0x61.should be_lowercase_hex
+  end
+
+  it "should recognize hexadecimal bytes" do
+    0x63.should be_hex
+  end
+
+  it "should recognize upper-case alpha bytes" do
+    0x4c.should be_uppercase_alpha
+  end
+
+  it "should recognize lower-case alpha bytes" do
+    0x71.should be_lowercase_alpha
+  end
+
+  it "should recognize alpha bytes" do
+    0x7a.should be_alpha
+  end
+
+  it "should recognize alpha-numeric bytes" do
+    0x69.should be_alpha_numeric
+  end
+
+  it "should recognize punctuation bytes" do
+    0x60.should be_punctuation
+  end
+
+  it "should recognize symbolic bytes" do
+    0x26.should be_symbolic
+  end
+
+  it "should recognize space bytes" do
+    0x20.should be_space
+  end
+
+  it "should recognize printable bytes" do
+    0x3f.should be_printable
+  end
+
+  it "should recognize control bytes" do
+    0x1b.should be_control
+  end
+
+  it "should recognize ASCII bytes" do
+    0x00.should be_ascii
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+gem 'rspec', '>=1.1.3'
+require 'spec'
+
+require 'chars/version'

data/spec/string_spec.rb

@@ -0,0 +1,65 @@
+require 'chars/extensions/string'
+
+require 'spec_helper'
+
+describe String do
+  it "should recognize numeric strings" do
+    "0987".should be_numeric
+  end
+
+  it "should recognize octal strings" do
+    "012".should be_octal
+  end
+
+  it "should recognize upper-case hexadecimal strings" do
+    "2D".should be_uppercase_hex
+  end
+
+  it "should recognize lower-case hexadecimal strings" do
+    "2d".should be_lowercase_hex
+  end
+
+  it "should recognize hexadecimal strings" do
+    "2dE3".should be_hex
+  end
+
+  it "should recognize upper-case alpha strings" do
+    "ABC".should be_uppercase_alpha
+  end
+
+  it "should recognize lower-case alpha strings" do
+    "abc".should be_lowercase_alpha
+  end
+
+  it "should recognize alpha strings" do
+    "abcDEF".should be_alpha
+  end
+
+  it "should recognize alpha-numeric strings" do
+    "abc123".should be_alpha_numeric
+  end
+
+  it "should recognize punctuation strings" do
+    "[...]".should be_punctuation
+  end
+
+  it "should recognize symbolic strings" do
+    "++".should be_symbolic
+  end
+
+  it "should recognize space strings" do
+    "  \t".should be_space
+  end
+
+  it "should recognize printable strings" do
+    "abc, [123]\nDEF".should be_printable
+  end
+
+  it "should recognize control strings" do
+    "\b\b\a".should be_control
+  end
+
+  it "should recognize ASCII strings" do
+    "lol\0".should be_ascii
+  end
+end

data/tasks/spec.rb

@@ -0,0 +1,9 @@
+require 'spec/rake/spectask'
+
+desc "Run all specifications"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.libs += ['lib', 'spec']
+  t.spec_opts = ['--colour', '--format', 'specdoc']
+end
+
+task :default => :spec

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: chars
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Postmodern
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.10.0
+    version: 
+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: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/chars.rb
+- lib/chars/char_set.rb
+- lib/chars/chars.rb
+- lib/chars/extensions.rb
+- lib/chars/extensions/integer.rb
+- lib/chars/extensions/string.rb
+- lib/chars/version.rb
+- tasks/spec.rb
+- spec/spec_helper.rb
+- spec/char_set_spec.rb
+- spec/chars_spec.rb
+- spec/integer_spec.rb
+- spec/string_spec.rb
+has_rdoc: true
+homepage: http://chars.rubyforge.org/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: chars
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Chars is a Ruby library for working with various character sets, recognizing text and generating random text from specific character sets.
+test_files: []
+