chars 0.2.3 → 0.2.4

data/spec/char_set_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'chars/chars'
+require 'chars/char_set'
 
 describe Chars::CharSet do
   let(:integer_range) { (0x41..0x43) }
@@ -10,205 +10,314 @@ describe Chars::CharSet do
   subject { described_class.new(*strings) }
 
   describe "#initialize" do
-    it "may be created with String arguments" do
-      set = described_class.new(*strings)
+    context "when given multiple String arguments" do
+      subject { described_class.new(*strings) }
 
-      expect(strings.all? { |s| set.include_char?(s) }).to be(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
 
-    it "may be created with an Array of Strings" do
-      set = described_class.new(strings)
+    context "when given an Array of Strings" do
+      subject { described_class.new(strings) }
 
-      expect(strings.all? { |s| set.include_char?(s) }).to be(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
 
-    it "may be created with a Range of Strings" do
-      set = described_class.new(string_range)
+    context "when given a Range of Strings" do
+      subject { described_class.new(string_range) }
 
-      expect(strings.all? { |s| set.include_char?(s) }).to be(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
 
-    it "may be created with Integer arguments" do
-      set = described_class.new(*integers)
+    context "when given multiple Integer arguments" do
+      subject { described_class.new(*integers) }
 
-      expect(integers.all? { |i| set.include?(i) }).to be(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
 
-    it "may be created with an Array of Integers" do
-      set = described_class.new(integers)
+    context "when given an Array of Integers" do
+      subject { described_class.new(integers) }
 
-      expect(integers.all? { |i| set.include?(i) }).to be(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
 
-    it "may be created with a Range of Integers" do
-      set = described_class.new(integer_range)
+    context "when given a Range of Integers" do
+      subject { described_class.new(integer_range) }
 
-      expect(integers.all? { |i| set.include?(i) }).to be(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
-    expect(subject.include_char?('A')).to be(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
-    expect(subject).to include(0x41)
+  describe "#include?" do
+    it "should include Integers" do
+      expect(subject).to include(0x41)
+    end
   end
 
-  it "should be able to select bytes" do
-    sub_set = subject.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 }
 
-    expect(sub_set).to be == [0x41, 0x42]
+      expect(sub_set).to be == [0x41, 0x42]
+    end
   end
 
-  it "should be able to select chars" do
-    sub_set = subject.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' }
 
-    expect(sub_set).to be == ['A', 'B']
+      expect(sub_set).to be == ['A', 'B']
+    end
   end
 
-  it "should return a random byte" do
-    expect(subject).to include(subject.random_byte)
+  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
-    expect(subject.include_char?(subject.random_char)).to be(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
-    expect(subject.each_random_byte(10).all? { |b|
-      subject.include?(b)
-    }).to be(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
-    expect(subject.each_random_char(10).all? { |c|
-      subject.include_char?(c)
-    }).to be(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
 
   describe "#random_bytes" do
     it "should return a random Array of bytes" do
-      bytes = subject.random_bytes(10)
+      random_bytes = subject.random_bytes(10)
 
-      expect(bytes.all? { |b| subject.include?(b) }).to be(true)
+      expect(random_bytes.all? { |b| subject.include?(b) }).to be(true)
     end
 
     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)
+        random_bytes = subject.random_bytes(5..10)
 
-        expect(bytes.length).to be_between(5, 10)
-        expect(bytes.all? { |b| subject.include?(b) }).to be(true)
+        expect(random_bytes.length).to be_between(5, 10)
+        expect(random_bytes.all? { |b| subject.include?(b) }).to be(true)
       end
     end
   end
 
   describe "#random_chars" do
     it "should return a random Array of chars" do
-      chars = subject.random_chars(10)
+      random_chars = subject.random_chars(10)
 
-      expect(chars.all? { |c| subject.include_char?(c) }).to be(true)
+      expect(random_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)
+        random_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)
+        expect(random_chars.length).to be_between(5, 10)
+        expect(random_chars.all? { |c| subject.include_char?(c) }).to be(true)
       end
     end
   end
 
   describe "#random_string" do
     it "should return a random String of chars" do
-      string = subject.random_string(10)
+      random_string = subject.random_string(10)
 
-      expect(string.chars.all? { |b| subject.include_char?(b) }).to be(true)
+      expect(random_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)
+        random_string = subject.random_string(5..10)
 
-        expect(string.length).to be_between(5, 10)
-        expect(string.chars.all? { |b| subject.include_char?(b) }).to be(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
   
   describe "#random_distinct_bytes" do
     it "should return a random Array of unique bytes" do
-      bytes = subject.random_distinct_bytes(10)
+      random_bytes = subject.random_distinct_bytes(10)
 
-      expect(bytes.uniq).to be == bytes
-      expect(bytes.all? { |b| subject.include?(b) }).to be(true)
+      expect(random_bytes.uniq).to be == random_bytes
+      expect(random_bytes.all? { |b| subject.include_byte?(b) }).to be(true)
     end
 
-    context "with a range of lengths" do
+    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)
+        random_bytes = subject.random_distinct_bytes(5..10)
 
-        expect(bytes.uniq).to be == bytes
-        expect(bytes.length).to be_between(5, 10)
-        expect(bytes.all? { |b| subject.include?(b) }).to be(true)
+        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
 
   describe "#random_distinct_chars" do
     it "should return a random Array of unique chars" do
-      chars = subject.random_distinct_chars(10)
+      random_chars = subject.random_distinct_chars(10)
 
-      expect(chars.uniq).to be == chars
-      expect(chars.all? { |c| subject.include_char?(c) }).to be(true)
+      expect(random_chars.uniq).to be == random_chars
+      expect(random_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)
+        random_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)
+        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
-    expect(subject).to be == described_class['A'..'Z']
+  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 = (subject | described_class['D'])
+  describe "#|" do
+    it "should be able to be unioned with another set of chars" do
+      super_set = (subject | described_class['D'])
 
-    expect(super_set).to be_kind_of(described_class)
-    expect(super_set).to be == described_class['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 = (subject - described_class['B'])
+  describe "#-" do
+    it "should be able to be removed from another set of chars" do
+      sub_set = (subject - described_class['B'])
 
-    expect(sub_set).to be_kind_of(described_class)
-    expect(sub_set).to be_subset(subject)
+      expect(sub_set).to be_kind_of(described_class)
+      expect(sub_set).to be_subset(subject)
+    end
   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"]
+    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
-      expect(subject.strings_in("AAAA!B!CCCCCC")).to be == [
-        "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
-    expect(subject).to be === "AABCBAA"
-    expect(subject).to_not be === "AA!!EE"
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chars
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Postmodern
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-26 00:00:00.000000000 Z
+date: 2021-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,11 +61,15 @@ files:
 - spec/extensions/integer_spec.rb
 - spec/extensions/string_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/postmodern/chars#readme
+homepage: https://github.com/postmodern/chars.rb#readme
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  documentation_uri: https://rubydoc.info/gems/chars
+  source_code_uri: https://github.com/postmodern/chars.rb
+  bug_tracker_uri: https://github.com/postmodern/chars.rb/issues
+  changelog_uri: https://github.com/postmodern/chars.rb/blob/master/ChangeLog.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -73,15 +77,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.2
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: A Ruby library for working with various character sets
 test_files: []