chars 0.2.0 → 0.2.4

data/spec/char_set_spec.rb

@@ -1,220 +1,323 @@
-require 'chars/chars'
-
 require 'spec_helper'
+require 'chars/char_set'
 
 describe Chars::CharSet do
-  before(:all) do
-    @integer_range = (0x41..0x43)
-    @string_range = ('A'..'Z')
-    @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
+    context "when given multiple String arguments" do
+      subject { described_class.new(*strings) }
 
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
+      it "must populate the char set with the String's chars" do
+        expect(strings.all? { |s| subject.include_char?(s) }).to be(true)
+      end
     end
-  end
 
-  it "may be created with an Array of Strings" do
-    @chars = Chars::CharSet.new(@strings)
+    context "when given an Array of Strings" do
+      subject { described_class.new(strings) }
 
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
+      it "must populate the char set with the String's chars" do
+        expect(strings.all? { |s| subject.include_char?(s) }).to be(true)
+      end
     end
-  end
 
-  it "may be created with a Range of Strings" do
-    @chars = Chars::CharSet.new(@string_range)
+    context "when given a Range of Strings" do
+      subject { described_class.new(string_range) }
 
-    @strings.each do |s|
-      @chars.include_char?(s).should == true
+      it "must populate the char set by enumerating over the String's chars" do
+        expect(strings.all? { |s| subject.include_char?(s) }).to be(true)
+      end
     end
-  end
 
-  it "may be created with Integer arguments" do
-    @chars = Chars::CharSet.new(*@integers)
+    context "when given multiple Integer arguments" do
+      subject { described_class.new(*integers) }
 
-    @integers.each do |i|
-      @chars.include?(i).should == true
+      it "must populate the char set using the Integers as bytes" do
+        expect(integers.all? { |i| subject.include?(i) }).to be(true)
+      end
     end
-  end
 
-  it "may be created with an Array of Integers" do
-    @chars = Chars::CharSet.new(@integers)
+    context "when given an Array of Integers" do
+      subject { described_class.new(integers) }
 
-    @integers.each do |i|
-      @chars.include?(i).should == true
+      it "must populate the char set using the Integers as bytes" do
+        expect(integers.all? { |i| subject.include?(i) }).to be(true)
+      end
     end
-  end
 
-  it "may be created with a Range of Integers" do
-    @chars = Chars::CharSet.new(@integer_range)
+    context "when given a Range of Integers" do
+      subject { described_class.new(integer_range) }
 
-    @integers.each do |i|
-      @chars.include?(i).should == true
+      it "must populate the char set by enumerating over the Integer's bytes" do
+        expect(integers.all? { |i| subject.include?(i) }).to be(true)
+      end
     end
   end
 
-  it "should include Strings" do
-    @char_set.include_char?('A').should == true
+  describe "#include_char?" do
+    it "should include Strings" do
+      expect(subject.include_char?('A')).to be(true)
+    end
   end
 
-  it "should include Integers" do
-    @char_set.include?(0x41).should == true
+  describe "#include?" do
+    it "should include Integers" do
+      expect(subject).to include(0x41)
+    end
   end
 
-  it "should be able to select bytes" do
-    @sub_chars = @char_set.select_bytes { |c| c <= 0x42 }
+  describe "#select_bytes" do
+    it "should be able to select bytes" do
+      sub_set = subject.select_bytes { |c| c <= 0x42 }
 
-    @sub_chars.should == [0x41, 0x42]
+      expect(sub_set).to be == [0x41, 0x42]
+    end
   end
 
-  it "should be able to select chars" do
-    @sub_chars = @char_set.select_chars { |c| c <= 'B' }
+  describe "#select_chars" do
+    it "should be able to select chars" do
+      sub_set = subject.select_chars { |c| c <= 'B' }
 
-    @sub_chars.should == ['A', 'B']
+      expect(sub_set).to be == ['A', 'B']
+    end
   end
 
-  it "should return a random byte" do
-    @char_set.include?(@char_set.random_byte).should == true
+  describe "#random_byte" do
+    it "should return a random byte" do
+      expect(subject).to include(subject.random_byte)
+    end
   end
 
-  it "should return a random char" do
-    @char_set.include_char?(@char_set.random_char).should == true
+  describe "#random_char" do
+    it "should return a random char" do
+      expect(subject.include_char?(subject.random_char)).to be(true)
+    end
   end
 
-  it "should iterate over n random bytes" do
-    @char_set.each_random_byte(10) do |b|
-      @char_set.include?(b).should == true
+  describe "#each_random_byte" do
+    it "should iterate over n random bytes" do
+      expect(subject.each_random_byte(10).all? { |b|
+        subject.include?(b)
+      }).to be(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
+  describe "#each_random_char" do
+    it "should iterate over n random chars" do
+      expect(subject.each_random_char(10).all? { |c|
+        subject.include_char?(c)
+      }).to be(true)
     end
   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
+      random_bytes = subject.random_bytes(10)
 
-    bytes.each do |b|
-      @char_set.include?(b).should == true
+      expect(random_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
+        random_bytes = subject.random_bytes(5..10)
 
-    chars.each do |c|
-      @char_set.include_char?(c).should == true
+        expect(random_bytes.length).to be_between(5, 10)
+        expect(random_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
+      random_chars = subject.random_chars(10)
 
-    bytes.length.between?(5, 10).should == true
-    bytes.each do |b|
-      @char_set.include?(b).should == true
+      expect(random_chars.all? { |c| subject.include_char?(c) }).to be(true)
     end
-  end
 
-  it "should return a random Array of chars with a varying length" do
-    chars = @char_set.random_chars(5..10)
+    context "with a range of lengths" do
+      it "should return a random Array of chars with a varying length" do
+        random_chars = subject.random_chars(5..10)
 
-    chars.length.between?(5, 10).should == true
-    chars.each do |c|
-      @char_set.include_char?(c).should == true
+        expect(random_chars.length).to be_between(5, 10)
+        expect(random_chars.all? { |c| subject.include_char?(c) }).to be(true)
+      end
     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
+  describe "#random_string" do
+    it "should return a random String of chars" do
+      random_string = subject.random_string(10)
+
+      expect(random_string.chars.all? { |b|
+        subject.include_char?(b)
+      }).to be(true)
     end
-  end
 
-  it "should return a random String of chars with a varying length" do
-    string = @char_set.random_string(5..10)
+    context "with a range of lengths" do
+      it "should return a random String of chars with a varying length" do
+        random_string = subject.random_string(5..10)
 
-    string.length.between?(5, 10)
-    string.each_byte do |b|
-      @char_set.include?(b).should == true
+        expect(random_string.length).to be_between(5, 10)
+        expect(random_string.chars.all? { |b|
+          subject.include_char?(b)
+        }).to be(true)
+      end
     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
+  describe "#random_distinct_bytes" do
+    it "should return a random Array of unique bytes" do
+      random_bytes = subject.random_distinct_bytes(10)
+
+      expect(random_bytes.uniq).to be == random_bytes
+      expect(random_bytes.all? { |b| subject.include_byte?(b) }).to be(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
+    context "with a Range of lengths" do
+      it "should return a random Array of unique bytes with a varying length" do
+        random_bytes = subject.random_distinct_bytes(5..10)
+
+        expect(random_bytes.uniq).to be == random_bytes
+        expect(random_bytes.length).to be_between(5, 10)
+        expect(random_bytes.all? { |b| subject.include_byte?(b) }).to be(true)
+      end
     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
+  describe "#random_distinct_chars" do
+    it "should return a random Array of unique chars" do
+      random_chars = subject.random_distinct_chars(10)
+
+      expect(random_chars.uniq).to be == random_chars
+      expect(random_chars.all? { |c| subject.include_char?(c) }).to be(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
+    context "with a range of lengths" do
+      it "should return a random Array of unique chars with a varying length" do
+        random_chars = subject.random_distinct_chars(5..10)
+
+        expect(random_chars.uniq).to be == random_chars
+        expect(random_chars.length).to be_between(5, 10)
+        expect(random_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'..'Z')]).should == true
+  describe "#==" do
+    it "should be able to be compared with another set of chars" do
+      expect(subject).to be == described_class['A'..'Z']
+    end
   end
 
-  it "should be able to be unioned with another set of chars" do
-    super_set = (@char_set | Chars::CharSet['D'])
+  describe "#|" do
+    it "should be able to be unioned with another set of chars" do
+      super_set = (subject | described_class['D'])
 
-    super_set.class.should == Chars::CharSet
-    super_set.should == Chars::CharSet[('A'..'Z'), 'D']
+      expect(super_set).to be_kind_of(described_class)
+      expect(super_set).to be == described_class['A'..'Z', 'D']
+    end
   end
 
-  it "should be able to be removed from another set of chars" do
-    sub_set = (@char_set - Chars::CharSet['B'])
+  describe "#-" do
+    it "should be able to be removed from another set of chars" do
+      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
   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
+    subject { described_class.new(['A', 'B', 'C']) }
+
+    let(:string) { "AAAA....BBBB....CCCC...." }
+
+    context "when given a block" do
+      it "should find sub-strings from a String belonging to the char set" do
+        expect { |b|
+          subject.strings_in(string,&b)
+        }.to yield_successive_args(
+          "AAAA",
+          "BBBB",
+          "CCCC"
+        )
+      end
+
+      it "must find sub-strings of a minimum length of 4" do
+        expect { |b|
+          subject.strings_in("A...BBB...CCCC",&b)
+        }.to yield_successive_args("CCCC")
+      end
+
+      context "and when the whole string matches the char set" do
+        it "should find one sub-string from a String belonging to the char set" do
+          expect { |b|
+            subject.strings_in("AAAA",&b)
+          }.to yield_successive_args("AAAA")
+        end
+      end
+
+      context "when the :length option is given" do
+        it "must find sub-strings of the given minimum length" do
+          expect { |b|
+            subject.strings_in("AAAA...BBBB...CCCCC", :length => 5, &b)
+          }.to yield_successive_args("CCCCC")
+        end
+      end
+
+      context "and when the block takes two arguments" do
+        it "must yield the sub-strings and their indexes" do
+          yielded_args = []
+
+          subject.strings_in(string) do |substring,index|
+            yielded_args << [substring, index]
+          end
+
+          expect(yielded_args).to eq(
+            [
+              ['AAAA', string.index('AAAA')],
+              ['BBBB', string.index('BBBB')],
+              ['CCCC', string.index('CCCC')]
+            ]
+          )
+        end
+      end
+    end
 
-  it "should find sub-strings from a String belonging to the char set" do
-    @char_set.strings_in("AAAA!B!CCCCCC").should == [
-      "AAAA",
-      "CCCCCC"
-    ]
+    context "when no block is given" do
+      it "must return an Array of sub-strings" do
+        expect(subject.strings_in(string)).to eq(
+          [
+            "AAAA",
+            "BBBB",
+            "CCCC"
+          ]
+        )
+      end
+
+      context "when given the :offset option" do
+        it "must return a Hash of the substrings and their indexes" do
+          expect(subject.strings_in(string, :offsets => true)).to eq(
+            {
+              "AAAA" => string.index("AAAA"),
+              "BBBB" => string.index("BBBB"),
+              "CCCC" => string.index("CCCC")
+            }
+          )
+        end
+      end
+    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 === "AA!!EE").should_not == true
+  describe "#===" do
+    it "should determine if a String is made up of the characters from the char set" do
+      expect(subject).to be === "AABCBAA"
+      expect(subject).to_not be === "AA!!EE"
+    end
   end
 end

data/spec/chars_spec.rb

@@ -1,115 +1,56 @@
-require 'chars/chars'
-
 require 'spec_helper'
+require 'chars/chars'
 
 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)
-    @signed_ascii_string = Chars.signed_ascii.random_string(10)
-    @ascii_string = Chars.ascii.random_string(10)
-    @visible_string = Chars.visible.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
+    expect(described_class::NUMERIC).to be =~ '0123456789'
   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
+    expect(described_class::OCTAL).to be =~ "01234567"
   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
+    expect(described_class::UPPERCASE_HEXADECIMAL).to be =~ "0123456789ABCDEF"
   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
+    expect(described_class::LOWERCASE_HEXADECIMAL).to be =~ "0123456789abcdef"
   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
+    expect(described_class::HEXADECIMAL).to be =~ "0123456789ABCDEFabcdef"
   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
+    expect(described_class::UPPERCASE_ALPHA).to be =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
   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
+    expect(described_class::LOWERCASE_ALPHA).to be =~ "abcdefghijklmnopqrstuvwxyz"
   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
+    expect(described_class::ALPHA).to be =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
   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
+    expect(described_class::ALPHA_NUMERIC).to be =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
   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
+    expect(described_class::VISIBLE).to be =~ "!\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   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
+    expect(described_class::SPACE).to be =~ "\t\n\v\f\r "
   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
+    expect(described_class::PUNCTUATION).to be =~ " !\"'(),-.:;?[]`{}~"
   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
+    expect(described_class::SYMBOLS).to be =~ " !\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
   end
 end