chars 0.2.0 → 0.2.1

data/lib/chars/chars.rb

@@ -2,59 +2,63 @@ require 'chars/char_set'
 
 module Chars
   # The numeric decimal character set
-  NUMERIC = CharSet.new('0'..'9')
+  NUMERIC = CharSet['0'..'9']
 
   # The octal character set
-  OCTAL = CharSet.new('0'..'7')
+  OCTAL = CharSet['0'..'7']
 
   # The upper-case hexadecimal character set
-  UPPERCASE_HEXADECIMAL = NUMERIC + ('A'..'F')
+  UPPERCASE_HEXADECIMAL = NUMERIC | CharSet['A'..'F']
 
   # The lower-case hexadecimal character set
-  LOWERCASE_HEXADECIMAL = NUMERIC + ('a'..'f')
+  LOWERCASE_HEXADECIMAL = NUMERIC | CharSet['a'..'f']
 
   # The hexadecimal character set
-  HEXADECIMAL = UPPERCASE_HEXADECIMAL + LOWERCASE_HEXADECIMAL
+  HEXADECIMAL = UPPERCASE_HEXADECIMAL | LOWERCASE_HEXADECIMAL
 
   # The upper-case alpha character set
-  UPPERCASE_ALPHA = CharSet.new('A'..'Z')
+  UPPERCASE_ALPHA = CharSet['A'..'Z']
 
   # The lower-case alpha character set
-  LOWERCASE_ALPHA = CharSet.new('a'..'z')
+  LOWERCASE_ALPHA = CharSet['a'..'z']
 
   # The alpha character set
-  ALPHA = UPPERCASE_ALPHA + LOWERCASE_ALPHA
+  ALPHA = UPPERCASE_ALPHA | LOWERCASE_ALPHA
 
   # The alpha-numeric character set
-  ALPHA_NUMERIC = ALPHA + NUMERIC
+  ALPHA_NUMERIC = ALPHA | NUMERIC
 
   # The punctuation character set
-  PUNCTUATION = CharSet.new(' ', '\'', '"', '`', ',', ';', ':', '~', '-',
-                            '(', ')', '[', ']', '{', '}', '.', '?', '!')
+  PUNCTUATION = CharSet[' ', '\'', '"', '`', ',', ';', ':', '~', '-',
+                        '(', ')', '[', ']', '{', '}', '.', '?', '!']
 
   # The symbolic character set
-  SYMBOLS = PUNCTUATION + ['@', '#', '$', '%', '^', '&', '*', '_', '+',
-    '=', '|', '\\', '<', '>', '/']
+  SYMBOLS = PUNCTUATION | CharSet[
+    '@', '#', '$', '%', '^', '&', '*', '_', '+',
+    '=', '|', '\\', '<', '>', '/'
+  ]
 
   # The space character set
   SPACE = CharSet.new(' ', "\f", "\n", "\r", "\t", "\v")
 
   # The set of printable characters (not including spaces)
-  VISIBLE = ALPHA_NUMERIC + ['\'', '"', '`', ',', ';', ':', '~', '-',
-            '(', ')', '[', ']', '{', '}', '.', '?', '!', '@', '#', '$',
-            '%', '^', '&', '*', '_', '+', '=', '|', '\\', '<', '>', '/']
+  VISIBLE = ALPHA_NUMERIC | CharSet[
+    '\'', '"', '`', ',', ';', ':', '~', '-',
+    '(', ')', '[', ']', '{', '}', '.', '?', '!', '@', '#', '$',
+    '%', '^', '&', '*', '_', '+', '=', '|', '\\', '<', '>', '/'
+  ]
   
   # The set of printable characters (including spaces)
-  PRINTABLE = ALPHA_NUMERIC + PUNCTUATION + SYMBOLS + SPACE
+  PRINTABLE = ALPHA_NUMERIC | PUNCTUATION | SYMBOLS | SPACE
 
   # The control-char character set
-  CONTROL = CharSet.new(0..0x1f, 0x7f)
+  CONTROL = CharSet[0..0x1f, 0x7f]
 
   # The signed ASCII character set
-  SIGNED_ASCII = CharSet.new(0..0x7f)
+  SIGNED_ASCII = CharSet[0..0x7f]
 
   # The full 8-bit character set
-  ASCII = CharSet.new(0..0xff)
+  ASCII = CharSet[0..0xff]
 
   #
   # The decimal-digit character set.

data/lib/chars/extensions/integer.rb

@@ -11,7 +11,7 @@ class Integer
   # @see Chars.numeric
   #
   def numeric?
-    Chars::NUMERIC.include?(self)
+    Chars::NUMERIC.include_byte?(self)
   end
 
   #
@@ -23,7 +23,7 @@ class Integer
   # @see Chars.octal
   #
   def octal?
-    Chars::OCTAL.include?(self)
+    Chars::OCTAL.include_byte?(self)
   end
 
   #
@@ -37,7 +37,7 @@ class Integer
   # @see Chars.uppercase_hexadecimal
   #
   def uppercase_hex?
-    Chars::UPPERCASE_HEXADECIMAL.include?(self)
+    Chars::UPPERCASE_HEXADECIMAL.include_byte?(self)
   end
 
   #
@@ -51,7 +51,7 @@ class Integer
   # @see Chars.lowercase_hexadecimal
   #
   def lowercase_hex?
-    Chars::LOWERCASE_HEXADECIMAL.include?(self)
+    Chars::LOWERCASE_HEXADECIMAL.include_byte?(self)
   end
 
   #
@@ -63,7 +63,7 @@ class Integer
   # @see Chars.hexadecimal
   #
   def hex?
-    Chars::HEXADECIMAL.include?(self)
+    Chars::HEXADECIMAL.include_byte?(self)
   end
 
   #
@@ -77,7 +77,7 @@ class Integer
   # @see Chars.uppercase_alpha
   #
   def uppercase_alpha?
-    Chars::UPPERCASE_ALPHA.include?(self)
+    Chars::UPPERCASE_ALPHA.include_byte?(self)
   end
 
   #
@@ -91,7 +91,7 @@ class Integer
   # @see Chars.lowercase_alpha
   #
   def lowercase_alpha?
-    Chars::LOWERCASE_ALPHA.include?(self)
+    Chars::LOWERCASE_ALPHA.include_byte?(self)
   end
 
   #
@@ -103,7 +103,7 @@ class Integer
   # @see Chars.alpha
   #
   def alpha?
-    Chars::ALPHA.include?(self)
+    Chars::ALPHA.include_byte?(self)
   end
 
   #
@@ -115,7 +115,7 @@ class Integer
   # @see Chars.alpha_numeric
   #
   def alpha_numeric?
-    Chars::ALPHA_NUMERIC.include?(self)
+    Chars::ALPHA_NUMERIC.include_byte?(self)
   end
 
   #
@@ -127,7 +127,7 @@ class Integer
   # @see Chars.punctuation
   #
   def punctuation?
-    Chars::PUNCTUATION.include?(self)
+    Chars::PUNCTUATION.include_byte?(self)
   end
 
   #
@@ -139,7 +139,7 @@ class Integer
   # @see Chars.symbols
   #
   def symbolic?
-    Chars::SYMBOLS.include?(self)
+    Chars::SYMBOLS.include_byte?(self)
   end
 
   #
@@ -151,7 +151,7 @@ class Integer
   # @see Chars.space
   #
   def space?
-    Chars::SPACE.include?(self)
+    Chars::SPACE.include_byte?(self)
   end
 
   #
@@ -163,7 +163,7 @@ class Integer
   # @see Chars.visible
   #
   def visible?
-    Chars::VISIBLE.include?(self)
+    Chars::VISIBLE.include_byte?(self)
   end
 
   #
@@ -175,7 +175,7 @@ class Integer
   # @see Chars.printable
   #
   def printable?
-    Chars::PRINTABLE.include?(self)
+    Chars::PRINTABLE.include_byte?(self)
   end
 
   #
@@ -188,7 +188,7 @@ class Integer
   # @see Chars.control
   #
   def control?
-    Chars::CONTROL.include?(self)
+    Chars::CONTROL.include_byte?(self)
   end
 
   #
@@ -200,7 +200,7 @@ class Integer
   # @see Chars.signed_ascii
   #
   def signed_ascii?
-    Chars::SIGNED_ASCII.include?(self)
+    Chars::SIGNED_ASCII.include_byte?(self)
   end
 
   #
@@ -212,7 +212,7 @@ class Integer
   # @see Chars.ascii
   #
   def ascii?
-    Chars::ASCII.include?(self)
+    Chars::ASCII.include_byte?(self)
   end
 
 end

data/lib/chars/version.rb

@@ -1,4 +1,4 @@
 module Chars
   # Chars version
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/spec/char_set_spec.rb

@@ -1,6 +1,5 @@
-require 'chars/chars'
-
 require 'spec_helper'
+require 'chars/chars'
 
 describe Chars::CharSet do
   before(:all) do
@@ -9,54 +8,44 @@ describe Chars::CharSet do
     @integers = @integer_range.to_a
     @strings = @string_range.to_a
 
-    @char_set = Chars::CharSet.new(*@strings)
+    @char_set = described_class.new(*@strings)
   end
 
-  it "may be created with String arguments" do
-    @chars = Chars::CharSet.new(*@strings)
+  describe "#initialize" do
+    it "may be created with String arguments" do
+      @chars = described_class.new(*@strings)
 
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
+      @strings.all? { |s| @chars.include_char?(s) }.should == true
     end
-  end
 
-  it "may be created with an Array of Strings" do
-    @chars = Chars::CharSet.new(@strings)
+    it "may be created with an Array of Strings" do
+      @chars = described_class.new(@strings)
 
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
+      @strings.all? { |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)
+    it "may be created with a Range of Strings" do
+      @chars = described_class.new(@string_range)
 
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
+      @strings.all? { |s| @chars.include_char?(s) }.should == true
     end
-  end
 
-  it "may be created with Integer arguments" do
-    @chars = Chars::CharSet.new(*@integers)
+    it "may be created with Integer arguments" do
+      @chars = described_class.new(*@integers)
 
-    @integers.each do |i|
-      @chars.include?(i).should == true
+      @integers.all? { |i| @chars.include?(i) }.should == true
     end
-  end
 
-  it "may be created with an Array of Integers" do
-    @chars = Chars::CharSet.new(@integers)
+    it "may be created with an Array of Integers" do
+      @chars = described_class.new(@integers)
 
-    @integers.each do |i|
-      @chars.include?(i).should == true
+      @integers.all? { |i| @chars.include?(i) }.should == true
     end
-  end
 
-  it "may be created with a Range of Integers" do
-    @chars = Chars::CharSet.new(@integer_range)
+    it "may be created with a Range of Integers" do
+      @chars = described_class.new(@integer_range)
 
-    @integers.each do |i|
-      @chars.include?(i).should == true
+      @integers.all? { |i| @chars.include?(i) }.should == true
     end
   end
 
@@ -65,7 +54,7 @@ describe Chars::CharSet do
   end
 
   it "should include Integers" do
-    @char_set.include?(0x41).should == true
+    @char_set.should include(0x41)
   end
 
   it "should be able to select bytes" do
@@ -81,7 +70,7 @@ describe Chars::CharSet do
   end
 
   it "should return a random byte" do
-    @char_set.include?(@char_set.random_byte).should == true
+    @char_set.should include(@char_set.random_byte)
   end
 
   it "should return a random char" do
@@ -89,117 +78,102 @@ describe Chars::CharSet do
   end
 
   it "should iterate over n random bytes" do
-    @char_set.each_random_byte(10) do |b|
-      @char_set.include?(b).should == true
-    end
+    @char_set.each_random_byte(10).all? { |b|
+      @char_set.include?(b)
+    }.should == true
   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
+    @char_set.each_random_char(10).all? { |c|
+      @char_set.include_char?(c)
+    }.should == true
   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
+    bytes.all? { |b| @char_set.include?(b) }.should == true
   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
+    chars.all? { |c| @char_set.include_char?(c) }.should == true
   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
+    bytes.length.should be_between(5, 10)
+    bytes.all? { |b| @char_set.include?(b) }.should == true
   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
+    chars.length.should be_between(5, 10)
+    chars.all? { |c| @char_set.include_char?(c) }.should == true
   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
+    string = @char_set.random_string(10)
+    
+    string.chars.all? { |b| @char_set.include_char?(b) }.should == true
   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
+    string.length.should be_between(5, 10)
+    string.chars.all? { |b| @char_set.include_char?(b) }.should == true
   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
+
+    bytes.uniq.should == bytes
+    bytes.all? { |b| @char_set.include?(b) }.should == true
   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
+
+    chars.uniq.should == chars
+    chars.all? { |c| @char_set.include_char?(c) }.should == true
   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
+
+    bytes.uniq.should == bytes
+    bytes.length.should be_between(5, 10)
+    bytes.all? { |b| @char_set.include?(b) }.should == true
   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
 
+    chars.uniq.should == chars
+    chars.length.should be_between(5, 10)
+    chars.all? { |c| @char_set.include_char?(c) }.should == true
+  end
 
   it "should be able to be compared with another set of chars" do
-    (@char_set == Chars::CharSet[('A'..'Z')]).should == true
+    @char_set.should == described_class['A'..'Z']
   end
 
   it "should be able to be unioned with another set of chars" do
-    super_set = (@char_set | Chars::CharSet['D'])
+    super_set = (@char_set | described_class['D'])
 
-    super_set.class.should == Chars::CharSet
-    super_set.should == Chars::CharSet[('A'..'Z'), 'D']
+    super_set.class.should == described_class
+    super_set.should == described_class['A'..'Z', 'D']
   end
 
   it "should be able to be removed from another set of chars" do
-    sub_set = (@char_set - Chars::CharSet['B'])
+    sub_set = (@char_set - described_class['B'])
 
-    sub_set.class.should == Chars::CharSet
-    sub_set.subset?(@char_set).should == true
+    sub_set.class.should == described_class
+    sub_set.should be_subset(@char_set)
   end
 
   it "should find one sub-string from a String belonging to the char set" do
@@ -214,7 +188,7 @@ describe Chars::CharSet do
   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 === "AA!!EE").should_not == true
+    @char_set.should === "AABCBAA"
+    @char_set.should_not === "AA!!EE"
   end
 end