chars 0.1.1 → 0.2.3

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'
+  # chars version
+  VERSION = '0.2.3'
 end

data/spec/char_set_spec.rb

@@ -1,186 +1,214 @@
-require 'chars/chars'
-
 require 'spec_helper'
+require 'chars/chars'
 
 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
+  let(:integer_range) { (0x41..0x43) }
+  let(:string_range)  { ('A'..'Z') }
+  let(:integers)      { integer_range.to_a }
+  let(:strings)       { string_range.to_a }
 
-    @char_set = Chars::CharSet.new(*@strings)
-  end
+  subject { described_class.new(*strings) }
 
-  it "may be created with String arguments" do
-    @chars = Chars::CharSet.new(*@strings)
+  describe "#initialize" do
+    it "may be created with String arguments" do
+      set = described_class.new(*strings)
 
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
+      expect(strings.all? { |s| set.include_char?(s) }).to be(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
+      set = described_class.new(strings)
 
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
+      expect(strings.all? { |s| set.include_char?(s) }).to be(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
+      set = described_class.new(string_range)
 
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
+      expect(strings.all? { |s| set.include_char?(s) }).to be(true)
     end
-  end
 
-  it "may be created with Integer arguments" do
-    @chars = Chars::CharSet.new(*@integers)
+    it "may be created with Integer arguments" do
+      set = described_class.new(*integers)
 
-    @integers.each do |i|
-      @chars.include?(i).should == true
+      expect(integers.all? { |i| set.include?(i) }).to be(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
+      set = described_class.new(integers)
 
-    @integers.each do |i|
-      @chars.include?(i).should == true
+      expect(integers.all? { |i| set.include?(i) }).to be(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
+      set = described_class.new(integer_range)
 
-    @integers.each do |i|
-      @chars.include?(i).should == true
+      expect(integers.all? { |i| set.include?(i) }).to be(true)
     end
   end
 
   it "should include Strings" do
-    @char_set.include_char?('A').should == true
+    expect(subject.include_char?('A')).to be(true)
   end
 
   it "should include Integers" do
-    @char_set.include?(0x41).should == true
+    expect(subject).to include(0x41)
   end
 
   it "should be able to select bytes" do
-    @sub_chars = @char_set.select_bytes { |c| c <= 0x42 }
+    sub_set = subject.select_bytes { |c| c <= 0x42 }
 
-    @sub_chars.should == [0x41, 0x42]
+    expect(sub_set).to be == [0x41, 0x42]
   end
 
   it "should be able to select chars" do
-    @sub_chars = @char_set.select_chars { |c| c <= 'B' }
+    sub_set = subject.select_chars { |c| c <= 'B' }
 
-    @sub_chars.should == ['A', 'B']
+    expect(sub_set).to be == ['A', 'B']
   end
 
   it "should return a random byte" do
-    @char_set.include?(@char_set.random_byte).should == true
+    expect(subject).to include(subject.random_byte)
   end
 
   it "should return a random char" do
-    @char_set.include_char?(@char_set.random_char).should == true
+    expect(subject.include_char?(subject.random_char)).to be(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
+    expect(subject.each_random_byte(10).all? { |b|
+      subject.include?(b)
+    }).to be(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
+    expect(subject.each_random_char(10).all? { |c|
+      subject.include_char?(c)
+    }).to be(true)
   end
 
-  it "should return a random Array of bytes" do
-    bytes = @char_set.random_bytes(10)
+  describe "#random_bytes" do
+    it "should return a random Array of bytes" do
+      bytes = subject.random_bytes(10)
 
-    bytes.each do |b|
-      @char_set.include?(b).should == true
+      expect(bytes.all? { |b| subject.include?(b) }).to be(true)
     end
-  end
 
-  it "should return a random Array of chars" do
-    chars = @char_set.random_chars(10)
+    context "with a range of lengths" do
+      it "should return a random Array of bytes with a varying length" do
+        bytes = subject.random_bytes(5..10)
 
-    chars.each do |c|
-      @char_set.include_char?(c).should == true
+        expect(bytes.length).to be_between(5, 10)
+        expect(bytes.all? { |b| subject.include?(b) }).to be(true)
+      end
     end
   end
 
-  it "should return a random Array of bytes with a varying length" do
-    bytes = @char_set.random_bytes(5..10)
+  describe "#random_chars" do
+    it "should return a random Array of chars" do
+      chars = subject.random_chars(10)
 
-    bytes.length.between?(5, 10).should == true
-    bytes.each do |b|
-      @char_set.include?(b).should == true
+      expect(chars.all? { |c| subject.include_char?(c) }).to be(true)
+    end
+
+    context "with a range of lengths" do
+      it "should return a random Array of chars with a varying length" do
+        chars = subject.random_chars(5..10)
+
+        expect(chars.length).to be_between(5, 10)
+        expect(chars.all? { |c| subject.include_char?(c) }).to be(true)
+      end
     end
   end
 
-  it "should return a random Array of chars with a varying length" do
-    chars = @char_set.random_chars(5..10)
+  describe "#random_string" do
+    it "should return a random String of chars" do
+      string = subject.random_string(10)
+
+      expect(string.chars.all? { |b| subject.include_char?(b) }).to be(true)
+    end
+
+    context "with a range of lengths" do
+      it "should return a random String of chars with a varying length" do
+        string = subject.random_string(5..10)
 
-    chars.length.between?(5, 10).should == true
-    chars.each do |c|
-      @char_set.include_char?(c).should == true
+        expect(string.length).to be_between(5, 10)
+        expect(string.chars.all? { |b| subject.include_char?(b) }).to be(true)
+      end
     end
   end
+  
+  describe "#random_distinct_bytes" do
+    it "should return a random Array of unique bytes" do
+      bytes = subject.random_distinct_bytes(10)
+
+      expect(bytes.uniq).to be == bytes
+      expect(bytes.all? { |b| subject.include?(b) }).to be(true)
+    end
+
+    context "with a range of lengths" do
+      it "should return a random Array of unique bytes with a varying length" do
+        bytes = subject.random_distinct_bytes(5..10)
 
-  it "should return a random String of chars" do
-    @char_set.random_string(10).each_byte do |b|
-      @char_set.include?(b).should == true
+        expect(bytes.uniq).to be == bytes
+        expect(bytes.length).to be_between(5, 10)
+        expect(bytes.all? { |b| subject.include?(b) }).to be(true)
+      end
     end
   end
 
-  it "should return a random String of chars with a varying length" do
-    string = @char_set.random_string(5..10)
+  describe "#random_distinct_chars" do
+    it "should return a random Array of unique chars" do
+      chars = subject.random_distinct_chars(10)
 
-    string.length.between?(5, 10)
-    string.each_byte do |b|
-      @char_set.include?(b).should == true
+      expect(chars.uniq).to be == chars
+      expect(chars.all? { |c| subject.include_char?(c) }).to be(true)
+    end
+
+    context "with a range of lengths" do
+      it "should return a random Array of unique chars with a varying length" do
+        chars = subject.random_distinct_chars(5..10)
+
+        expect(chars.uniq).to be == chars
+        expect(chars.length).to be_between(5, 10)
+        expect(chars.all? { |c| subject.include_char?(c) }).to be(true)
+      end
     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
+    expect(subject).to be == 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 = (subject | described_class['D'])
 
-    super_set.class.should == Chars::CharSet
-    super_set.should == Chars::CharSet['A', 'B', 'C', 'D']
+    expect(super_set).to be_kind_of(described_class)
+    expect(super_set).to be == 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 = (subject - described_class['B'])
 
-    sub_set.class.should == Chars::CharSet
-    sub_set.subset?(@char_set).should == true
+    expect(sub_set).to be_kind_of(described_class)
+    expect(sub_set).to be_subset(subject)
   end
 
-  it "should find one sub-string from a String belonging to the char set" do
-    @char_set.strings_in("AAAA").should == ["AAAA"]
-  end
+  describe "#strings_in" do
+    it "should find one sub-string from a String belonging to the char set" do
+      expect(subject.strings_in("AAAA")).to be == ["AAAA"]
+    end
 
-  it "should find sub-strings from a String belonging to the char set" do
-    @char_set.strings_in("AAAAXBXCCCCCC").should == [
-      "AAAA",
-      "CCCCCC"
-    ]
+    it "should find sub-strings from a String belonging to the char set" do
+      expect(subject.strings_in("AAAA!B!CCCCCC")).to be == [
+        "AAAA",
+        "CCCCCC"
+      ]
+    end
   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
+    expect(subject).to be === "AABCBAA"
+    expect(subject).to_not be === "AA!!EE"
   end
 end