chars 0.2.1 → 0.3.0

data/spec/chars_spec.rb

@@ -2,55 +2,211 @@ require 'spec_helper'
 require 'chars/chars'
 
 describe Chars do
-  it "should provide a numeric CharSet" do
-    Chars::NUMERIC =~ '0123456789'
+  let(:numeric_chars) { '0123456789'.chars }
+
+  describe "NUMERIC" do
+    subject { described_class::NUMERIC }
+
+    it "must contain numeric characters" do
+      expect(subject.chars).to match_array(numeric_chars)
+    end
+  end
+
+  describe "DIGITS" do
+    subject { described_class::DIGITS }
+
+    it "must equal NUMERIC" do
+      expect(subject).to be(described_class::NUMERIC)
+    end
+  end
+
+  describe "OCTAL" do
+    subject { described_class::OCTAL }
+
+    it "must contain all octal characters" do
+      expect(subject.chars).to match_array("01234567".chars)
+    end
+  end
+
+  let(:uppercase_hex_chars) { "0123456789ABCDEF".chars }
+
+  describe "UPPERCASE_HEXADECIMAL" do
+    subject { described_class::UPPERCASE_HEXADECIMAL }
+
+    it "must contain all upper-case hexadecimal characters" do
+      expect(subject.chars).to match_array(uppercase_hex_chars)
+    end
+  end
+
+  let(:lowercase_hex_chars) { "0123456789abcdef".chars }
+
+  describe "LOWERCASE_HEXADECIMAL" do
+    subject { described_class::LOWERCASE_HEXADECIMAL }
+
+    it "must contain all lower-case hexadecimal characters" do
+      expect(subject.chars).to match_array(lowercase_hex_chars)
+    end
+  end
+
+  describe "HEXADECIMAL" do
+    subject { described_class::HEXADECIMAL }
+
+    it "must contain both upper-case and lower-case hexadecimal characters" do
+      expect(subject.chars).to match_array(uppercase_hex_chars | lowercase_hex_chars)
+    end
+  end
+
+  let(:uppercase_alpha_chars) { "ABCDEFGHIJKLMNOPQRSTUVWXYZ".chars }
+
+  describe "UPPERCASE_ALPHA" do
+    subject { described_class::UPPERCASE_ALPHA }
+
+    it "must contain all upper-case alpha characters" do
+      expect(subject.chars).to match_array(uppercase_alpha_chars)
+    end
+  end
+
+  let(:lowercase_alpha_chars) { "abcdefghijklmnopqrstuvwxyz".chars }
+
+  describe "LOWERCASE_ALPHA" do
+    subject { described_class::LOWERCASE_ALPHA }
+
+    it "must contain all lower-case alpha characters" do
+      expect(subject.chars).to match_array(lowercase_alpha_chars)
+    end
   end
 
-  it "should provide an octal CharSet" do
-    Chars::OCTAL =~ "01234567"
+  let(:alpha_chars) { uppercase_alpha_chars | lowercase_alpha_chars }
+
+  describe "ALPHA" do
+    subject { described_class::ALPHA }
+
+    it "must contain all alpha characters" do
+      expect(subject.chars).to match_array(alpha_chars)
+    end
   end
 
-  it "should provide an upper-case hexadecimal CharSet" do
-    Chars::UPPERCASE_HEXADECIMAL =~ "0123456789ABCDEF"
+  let(:alpha_numeric_chars) { alpha_chars | numeric_chars }
+
+  describe "ALPHA_NUMERIC" do
+    subject { described_class::ALPHA_NUMERIC }
+
+    it "must contain all alpha-numeric characters" do
+      expect(subject.chars).to match_array(alpha_numeric_chars)
+    end
   end
 
-  it "should provide a lower-case hexadecimal CharSet" do
-    Chars::LOWERCASE_HEXADECIMAL =~ "0123456789abcdef"
+  let(:punctuation_chars) { " !\"'(),-.:;?[]`{}~".chars }
+
+  describe "PUNCTUATION" do
+    subject { described_class::PUNCTUATION }
+
+    it "must contain all punctuation characters" do
+      expect(subject.chars).to match_array(punctuation_chars)
+    end
   end
 
-  it "should provide a hexadecimal CharSet" do
-    Chars::HEXADECIMAL =~ "0123456789ABCDEFabcdef"
+  let(:symbolic_chars) { " !\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~".chars }
+
+  describe "SYMBOLS" do
+    subject { described_class::SYMBOLS }
+
+    it "must contain all symbolic characters" do
+      expect(subject.chars).to match_array(symbolic_chars)
+    end
   end
 
-  it "should provide an upper-case alpha CharSet" do
-    Chars::UPPERCASE_ALPHA =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  let(:whitespace_chars) { "\t\n\v\f\r ".chars }
+
+  describe "WHITESPACE" do
+    subject { described_class::WHITESPACE }
+
+    it "must contain all white-space characters" do
+      expect(subject.chars).to match_array(whitespace_chars)
+    end
   end
 
-  it "should provide a lower-case alpha CharSet" do
-    Chars::LOWERCASE_ALPHA =~ "abcdefghijklmnopqrstuvwxyz"
+  describe "SPACE" do
+    subject { described_class::SPACE }
+
+    it "must equal WHITESPACE" do
+      expect(subject).to be(described_class::WHITESPACE)
+    end
   end
 
-  it "should provide an alpha CharSet" do
-    Chars::ALPHA =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+  describe "VISIBLE" do
+    subject { described_class::VISIBLE }
+
+    it "must contain all all alpha-numeric, symbols, and some punctuation" do
+      expect(subject.chars).to match_array(alpha_numeric_chars | "!\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~".chars)
+    end
   end
 
-  it "should provide an alpha-numeric CharSet" do
-    Chars::ALPHA_NUMERIC =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+  describe "PRINTABLE" do
+    subject { described_class::PRINTABLE }
+
+    it "must contain all alpha-numeric, punctuation, symbols, and whitespace characters" do
+      expect(subject.chars).to match_array(
+        alpha_numeric_chars |
+        punctuation_chars |
+        symbolic_chars |
+        whitespace_chars
+      )
+    end
   end
-  
-  it "should provide a visible CharSet" do
-    Chars::VISIBLE =~ "!\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+
+  describe "CONTROL" do
+    subject { described_class::CONTROL }
+
+    it "must contain ASCII bytes 0x00 - 0x1f and 0x7f" do
+      expect(subject.bytes).to eq([*0x00..0x1f, 0x7f])
+    end
   end
 
-  it "should provide a space CharSet" do
-    Chars::SPACE =~ "\t\n\v\f\r "
+  describe "SIGNED_ASCII" do
+    subject { described_class::SIGNED_ASCII }
+
+    it "must contain ASCII bytes 0x00 - 0x7f" do
+      expect(subject.bytes).to eq([*0x00..0x7f])
+    end
   end
 
-  it "should provide a punctuation CharSet" do
-    Chars::PUNCTUATION =~ " !\"'(),-.:;?[]`{}~"
+  describe "ASCII" do
+    subject { described_class::ASCII }
+
+    it "must contain ASCII bytes 0x00 - 0xff" do
+      expect(subject.bytes).to eq([*0x00..0xff])
+    end
   end
 
-  it "should provide a symbols CharSet" do
-    Chars::SYMBOLS =~ " !\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
+  {
+    :numeric => :NUMERIC,
+    :digits  => :DIGITS,
+    :octal   => :OCTAL,
+
+    :uppercase_hexadecimal => :UPPERCASE_HEXADECIMAL,
+    :lowercase_hexadecimal => :LOWERCASE_HEXADECIMAL,
+    :hexadecimal => :HEXADECIMAL,
+
+    :uppercase_alpha => :UPPERCASE_ALPHA,
+    :lowercase_alpha => :LOWERCASE_ALPHA,
+    :alpha => :ALPHA,
+
+    :punctuation => :PUNCTUATION,
+    :symbols     => :SYMBOLS,
+    :whitespace  => :WHITESPACE,
+    :space       => :SPACE,
+    :visible     => :VISIBLE,
+    :printable   => :PRINTABLE,
+    :control     => :CONTROL,
+
+    :signed_ascii => :SIGNED_ASCII,
+    :ascii        => :ASCII
+  }.each do |method,constant|
+    describe ".#{method}" do
+      it "must return #{constant}" do
+        expect(subject.send(method)).to be(described_class.const_get(constant))
+      end
+    end
   end
 end

data/spec/extensions/integer_spec.rb

@@ -3,71 +3,71 @@ require 'chars/extensions/integer'
 
 describe Integer do
   it "should recognize numeric bytes" do
-    0x39.should be_numeric
+    expect(0x39).to be_numeric
   end
 
   it "should recognize octal bytes" do
-    0x30.should be_octal
+    expect(0x30).to be_octal
   end
 
   it "should recognize upper-case hexadecimal bytes" do
-    0x44.should be_uppercase_hex
+    expect(0x44).to be_uppercase_hex
   end
 
   it "should recognize lower-case hexadecimal bytes" do
-    0x61.should be_lowercase_hex
+    expect(0x61).to be_lowercase_hex
   end
 
   it "should recognize hexadecimal bytes" do
-    0x63.should be_hex
+    expect(0x63).to be_hex
   end
 
   it "should recognize upper-case alpha bytes" do
-    0x4c.should be_uppercase_alpha
+    expect(0x4c).to be_uppercase_alpha
   end
 
   it "should recognize lower-case alpha bytes" do
-    0x71.should be_lowercase_alpha
+    expect(0x71).to be_lowercase_alpha
   end
 
   it "should recognize alpha bytes" do
-    0x7a.should be_alpha
+    expect(0x7a).to be_alpha
   end
 
   it "should recognize alpha-numeric bytes" do
-    0x69.should be_alpha_numeric
+    expect(0x69).to be_alpha_numeric
   end
 
   it "should recognize punctuation bytes" do
-    0x60.should be_punctuation
+    expect(0x60).to be_punctuation
   end
 
   it "should recognize symbolic bytes" do
-    0x26.should be_symbolic
+    expect(0x26).to be_symbolic
   end
 
   it "should recognize space bytes" do
-    0x20.should be_space
+    expect(0x20).to be_space
   end
 
   it "should recognize visible bytes" do
-    0x41.should be_visible
-    0x20.should_not be_visible
+    expect(0x41).to be_visible
+    expect(0x20).to_not be_visible
   end
 
   it "should recognize printable bytes" do
-    0x3f.should be_printable
+    expect(0x3f).to be_printable
   end
 
   it "should recognize control bytes" do
-    0x1b.should be_control
+    expect(0x1b).to be_control
   end
 
   it "should recognize signed ASCII bytes" do
-    0x00.should be_signed_ascii
+    expect(0x00).to be_signed_ascii
   end
 
   it "should recognize ASCII bytes" do
-    0x80.should be_ascii
+    expect(0x80).to be_ascii
   end
 end

data/spec/extensions/string_spec.rb

@@ -1,73 +1,75 @@
+# encoding: US-ASCII
+
 require 'spec_helper'
 require 'chars/extensions/string'
 
 describe String do
   it "should recognize numeric strings" do
-    "0987".should be_numeric
+    expect("0987").to be_numeric
   end
 
   it "should recognize octal strings" do
-    "012".should be_octal
+    expect("012").to be_octal
   end
 
   it "should recognize upper-case hexadecimal strings" do
-    "2D".should be_uppercase_hex
+    expect("2D").to be_uppercase_hex
   end
 
   it "should recognize lower-case hexadecimal strings" do
-    "2d".should be_lowercase_hex
+    expect("2d").to be_lowercase_hex
   end
 
   it "should recognize hexadecimal strings" do
-    "2dE3".should be_hex
+    expect("2dE3").to be_hex
   end
 
   it "should recognize upper-case alpha strings" do
-    "ABC".should be_uppercase_alpha
+    expect("ABC").to be_uppercase_alpha
   end
 
   it "should recognize lower-case alpha strings" do
-    "abc".should be_lowercase_alpha
+    expect("abc").to be_lowercase_alpha
   end
 
   it "should recognize alpha strings" do
-    "abcDEF".should be_alpha
+    expect("abcDEF").to be_alpha
   end
 
   it "should recognize alpha-numeric strings" do
-    "abc123".should be_alpha_numeric
+    expect("abc123").to be_alpha_numeric
   end
 
   it "should recognize punctuation strings" do
-    "[...]".should be_punctuation
+    expect("[...]").to be_punctuation
   end
 
   it "should recognize symbolic strings" do
-    "++".should be_symbolic
+    expect("++").to be_symbolic
   end
 
   it "should recognize space strings" do
-    "  \t".should be_space
+    expect("  \t").to be_space
   end
 
   it "should recognize visible strings" do
-    "abc".should be_visible
-    "ab c".should_not be_visible
+    expect("abc").to be_visible
+    expect("ab c").to_not be_visible
   end
 
   it "should recognize printable strings" do
-    "abc, [123]\nDEF".should be_printable
+    expect("abc, [123]\nDEF").to be_printable
   end
 
   it "should recognize control strings" do
-    "\b\b\a".should be_control
+    expect("\b\b\a").to be_control
   end
 
   it "should recognize signed ASCII strings" do
-    "lol\0".should be_signed_ascii
+    expect("lol\0").to be_signed_ascii
   end
 
   it "should recognize ASCII strings" do
-    "\xff\xfe".should be_ascii
+    expect("\xff\xfe").to be_ascii
   end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,2 @@
-gem 'rspec', '~> 2.4'
 require 'rspec'
-
 require 'chars/version'

data/spec/string_enumerator_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'chars/char_set'
+require 'chars/string_enumerator'
+
+describe Chars::StringEnumerator do
+  let(:char_set) { Chars::CharSet['a', 'b', 'c'] }
+  let(:length)   { 3 }
+
+  subject { described_class.new(char_set,length) }
+
+  describe "#initialize" do
+    it "must set #char_set" do
+      expect(subject.char_set).to eq(char_set)
+    end
+
+    it "must set #length" do
+      expect(subject.length).to eq(length)
+    end
+  end
+
+  describe "#each" do
+    let(:expected_strings) do
+      %w[
+        aaa
+        aab
+        aac
+        aba
+        abb
+        abc
+        aca
+        acb
+        acc
+        baa
+        bab
+        bac
+        bba
+        bbb
+        bbc
+        bca
+        bcb
+        bcc
+        caa
+        cab
+        cac
+        cba
+        cbb
+        cbc
+        cca
+        ccb
+        ccc
+      ]
+    end
+
+    context "when a block is given" do
+      it "must enumerate through each sequential string in the char-set and of the desired length" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*expected_strings)
+      end
+
+      context "when the length is 1" do
+        let(:length) { 1 }
+
+        it "must enumerate over each individual character" do
+          expect { |b|
+            subject.each(&b)
+          }.to yield_successive_args(*char_set.chars)
+        end
+      end
+
+      context "when the length is 0" do
+        let(:length) { 0 }
+
+        it "must yield an empty String" do
+          expect { |b|
+            subject.each(&b)
+          }.to yield_successive_args("")
+        end
+      end
+
+      context "when #char_set is empty" do
+        let(:char_set) { Chars::CharSet.new }
+
+        it "must yield an empty String" do
+          expect { |b|
+            subject.each(&b)
+          }.to_not yield_control
+        end
+      end
+    end
+
+    context "when no block is given" do
+      it "must return an Enumerator object" do
+        expect(subject.each).to be_kind_of(Enumerator)
+        expect(subject.each.to_a).to eq(expected_strings)
+      end
+    end
+  end
+end