chars 0.2.2 → 0.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a22fd4d88e24c4f378880de5e324ac4acc4ff197c541baa1b840a8852d420afa
+  data.tar.gz: ad9c7a38b080490366aaf4142eb642224d551da165ddeedfb4fc1fd0e6bf0728
+SHA512:
+  metadata.gz: 5886283079f3bfcf060facf0b0520a51f75066b0301a87750d262e1e4326fad164e541c9580aad1a3f86810430732b2e1933b2ccee26eda6667d0da2aaf2bf00
+  data.tar.gz: 0313dcedc0872cc15f84804bdea985bf726040b48d48018084800c8e07f4224267b5802df4da9d68c5ce79ff0239e4af7138db522fa8523647251524d51e6ba1

data/.github/workflows/ruby.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on: [ push, pull_request ]
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - 2.4
+          - 2.5
+          - 2.6
+          - 2.7
+          - 3.0
+          - jruby
+    name: Ruby ${{ matrix.ruby }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Install dependencies
+        run: bundle install --jobs 4 --retry 3
+      - name: Run tests
+        run: bundle exec rake test

data/.gitignore

@@ -1,6 +1,7 @@
-doc
-pkg
-tmp/*
+/Gemfile.lock
+/doc/
+/pkg/
+/vendor/bundle
 .DS_Store
 .yardoc
 *.swp

data/ChangeLog.md

@@ -1,3 +1,7 @@
+### 0.2.3 / 2020-12-25
+
+* Change {Chars::CharSet} to inherit from `Set`, instead of `SortedSet`.
+
 ### 0.2.2 / 2012-05-28
 
 * {Chars::CharSet#initialize} now raises a TypeError when given arguments

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'rake'
+  gem 'rubygems-tasks', '~> 0.2'
+  gem 'rspec',          '~> 3.0'
+  gem 'kramdown'
+  gem 'yard',           '~> 0.9'
+end

data/Rakefile

@@ -1,36 +1,12 @@
 require 'rubygems'
-require 'rake'
 
-begin
-  gem 'rubygems-tasks', '~> 0.1'
-  require 'rubygems/tasks'
+require 'rubygems/tasks'
+Gem::Tasks.new
 
-  Gem::Tasks.new
-rescue LoadError => e
-  warn e.message
-  warn "Run `gem install rubygems-tasks` to install 'rubygems/tasks'."
-end
-
-begin
-  gem 'rspec', '~> 2.4'
-  require 'rspec/core/rake_task'
-
-  RSpec::Core::RakeTask.new
-rescue LoadError => e
-  task :spec do
-    abort "Please run `gem install rspec` to install RSpec."
-  end
-end
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
 task :test => :spec
 task :default => :spec
 
-begin
-  gem 'yard', '~> 0.7'
-  require 'yard'
-
-  YARD::Rake::YardocTask.new  
-rescue LoadError => e
-  task :yard do
-    abort "Please run `gem install yard` to install YARD."
-  end
-end
+require 'yard'
+YARD::Rake::YardocTask.new  

data/gemspec.yml

@@ -13,6 +13,4 @@ has_yard: true
 required_ruby_version: ">= 1.8.7"
 
 development_dependencies:
-  rubygems-tasks: ~> 0.1
-  rspec: ~> 2.4
-  yard: ~> 0.7
+  bundler: ~> 2.0

data/lib/chars/char_set.rb

@@ -1,7 +1,7 @@
 require 'set'
 
 module Chars
-  class CharSet < SortedSet
+  class CharSet < Set
 
     #
     # Creates a new CharSet object.
@@ -120,7 +120,7 @@ module Chars
     #   If no block is given, an enumerator object will be returned.
     #
     def each_char
-      return enum_for(:each_char) unless block_given?
+      return enum_for(__method__) unless block_given?
 
       each { |byte| yield @chars[byte] }
     end
@@ -191,7 +191,7 @@ module Chars
     #   If no block is given, an enumerator object will be returned.
     #
     def each_random_byte(n,&block)
-      return enum_for(:each_random_byte,n) unless block_given?
+      return enum_for(__method__,n) unless block_given?
 
       n.times { yield random_byte }
       return nil
@@ -213,7 +213,7 @@ module Chars
     #   If no block is given, an enumerator object will be returned.
     #
     def each_random_char(n,&block)
-      return enum_for(:each_random_char,n) unless block_given?
+      return enum_for(__method__,n) unless block_given?
 
       each_random_byte(n) { |byte| yield @chars[byte] }
     end

data/lib/chars/version.rb

@@ -1,4 +1,4 @@
 module Chars
   # chars version
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
 end

data/spec/char_set_spec.rb

@@ -2,193 +2,213 @@ require 'spec_helper'
 require 'chars/chars'
 
 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 = described_class.new(*@strings)
-  end
+  subject { described_class.new(*strings) }
 
   describe "#initialize" do
     it "may be created with String arguments" do
-      @chars = described_class.new(*@strings)
+      set = described_class.new(*strings)
 
-      @strings.all? { |s| @chars.include_char?(s) }.should == true
+      expect(strings.all? { |s| set.include_char?(s) }).to be(true)
     end
 
     it "may be created with an Array of Strings" do
-      @chars = described_class.new(@strings)
+      set = described_class.new(strings)
 
-      @strings.all? { |s| @chars.include_char?(s) }.should == true
+      expect(strings.all? { |s| set.include_char?(s) }).to be(true)
     end
 
     it "may be created with a Range of Strings" do
-      @chars = described_class.new(@string_range)
+      set = described_class.new(string_range)
 
-      @strings.all? { |s| @chars.include_char?(s) }.should == true
+      expect(strings.all? { |s| set.include_char?(s) }).to be(true)
     end
 
     it "may be created with Integer arguments" do
-      @chars = described_class.new(*@integers)
+      set = described_class.new(*integers)
 
-      @integers.all? { |i| @chars.include?(i) }.should == true
+      expect(integers.all? { |i| set.include?(i) }).to be(true)
     end
 
     it "may be created with an Array of Integers" do
-      @chars = described_class.new(@integers)
+      set = described_class.new(integers)
 
-      @integers.all? { |i| @chars.include?(i) }.should == true
+      expect(integers.all? { |i| set.include?(i) }).to be(true)
     end
 
     it "may be created with a Range of Integers" do
-      @chars = described_class.new(@integer_range)
+      set = described_class.new(integer_range)
 
-      @integers.all? { |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.should include(0x41)
+    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.should include(@char_set.random_byte)
+    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).all? { |b|
-      @char_set.include?(b)
-    }.should == true
+    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).all? { |c|
-      @char_set.include_char?(c)
-    }.should == true
+    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.all? { |b| @char_set.include?(b) }.should == true
-  end
+      expect(bytes.all? { |b| subject.include?(b) }).to be(true)
+    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.all? { |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.should be_between(5, 10)
-    bytes.all? { |b| @char_set.include?(b) }.should == true
-  end
+      expect(chars.all? { |c| subject.include_char?(c) }).to be(true)
+    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
+        chars = subject.random_chars(5..10)
 
-    chars.length.should be_between(5, 10)
-    chars.all? { |c| @char_set.include_char?(c) }.should == true
+        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 String of chars" do
-    string = @char_set.random_string(10)
-    
-    string.chars.all? { |b| @char_set.include_char?(b) }.should == true
-  end
+  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
 
-  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
+        string = subject.random_string(5..10)
 
-    string.length.should be_between(5, 10)
-    string.chars.all? { |b| @char_set.include_char?(b) }.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
   
-  it "should return a random Array of unique bytes" do
-    bytes = @char_set.random_distinct_bytes(10)
+  describe "#random_distinct_bytes" do
+    it "should return a random Array of unique bytes" do
+      bytes = subject.random_distinct_bytes(10)
 
-    bytes.uniq.should == bytes
-    bytes.all? { |b| @char_set.include?(b) }.should == true
-  end
+      expect(bytes.uniq).to be == bytes
+      expect(bytes.all? { |b| subject.include?(b) }).to be(true)
+    end
 
-  it "should return a random Array of unique chars" do
-    chars = @char_set.random_distinct_chars(10)
+    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)
 
-    chars.uniq.should == chars
-    chars.all? { |c| @char_set.include_char?(c) }.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 Array of unique bytes with a varying length" do
-    bytes = @char_set.random_distinct_bytes(5..10)
+  describe "#random_distinct_chars" do
+    it "should return a random Array of unique chars" do
+      chars = subject.random_distinct_chars(10)
 
-    bytes.uniq.should == bytes
-    bytes.length.should be_between(5, 10)
-    bytes.all? { |b| @char_set.include?(b) }.should == true
-  end
+      expect(chars.uniq).to be == chars
+      expect(chars.all? { |c| subject.include_char?(c) }).to be(true)
+    end
 
-  it "should return a random Array of unique chars with a varying length" do
-    chars = @char_set.random_distinct_chars(5..10)
+    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)
 
-    chars.uniq.should == chars
-    chars.length.should be_between(5, 10)
-    chars.all? { |c| @char_set.include_char?(c) }.should == true
+        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.should == described_class['A'..'Z']
+    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 | described_class['D'])
+    super_set = (subject | described_class['D'])
 
-    super_set.class.should == described_class
-    super_set.should == 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
 
   it "should be able to be removed from another set of chars" do
-    sub_set = (@char_set - described_class['B'])
+    sub_set = (subject - described_class['B'])
 
-    sub_set.class.should == described_class
-    sub_set.should be_subset(@char_set)
+    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("AAAA!B!CCCCCC").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.should === "AABCBAA"
-    @char_set.should_not === "AA!!EE"
+    expect(subject).to be === "AABCBAA"
+    expect(subject).to_not be === "AA!!EE"
   end
 end

data/spec/chars_spec.rb

@@ -3,54 +3,54 @@ require 'chars/chars'
 
 describe Chars do
   it "should provide a numeric CharSet" do
-    Chars::NUMERIC =~ '0123456789'
+    expect(described_class::NUMERIC).to be =~ '0123456789'
   end
 
   it "should provide an octal CharSet" do
-    Chars::OCTAL =~ "01234567"
+    expect(described_class::OCTAL).to be =~ "01234567"
   end
 
   it "should provide an upper-case hexadecimal CharSet" do
-    Chars::UPPERCASE_HEXADECIMAL =~ "0123456789ABCDEF"
+    expect(described_class::UPPERCASE_HEXADECIMAL).to be =~ "0123456789ABCDEF"
   end
 
   it "should provide a lower-case hexadecimal CharSet" do
-    Chars::LOWERCASE_HEXADECIMAL =~ "0123456789abcdef"
+    expect(described_class::LOWERCASE_HEXADECIMAL).to be =~ "0123456789abcdef"
   end
 
   it "should provide a hexadecimal CharSet" do
-    Chars::HEXADECIMAL =~ "0123456789ABCDEFabcdef"
+    expect(described_class::HEXADECIMAL).to be =~ "0123456789ABCDEFabcdef"
   end
 
   it "should provide an upper-case alpha CharSet" do
-    Chars::UPPERCASE_ALPHA =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    expect(described_class::UPPERCASE_ALPHA).to be =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
   end
 
   it "should provide a lower-case alpha CharSet" do
-    Chars::LOWERCASE_ALPHA =~ "abcdefghijklmnopqrstuvwxyz"
+    expect(described_class::LOWERCASE_ALPHA).to be =~ "abcdefghijklmnopqrstuvwxyz"
   end
 
   it "should provide an alpha CharSet" do
-    Chars::ALPHA =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+    expect(described_class::ALPHA).to be =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
   end
 
   it "should provide an alpha-numeric CharSet" do
-    Chars::ALPHA_NUMERIC =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+    expect(described_class::ALPHA_NUMERIC).to be =~ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
   end
   
   it "should provide a visible CharSet" do
-    Chars::VISIBLE =~ "!\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
+    expect(described_class::VISIBLE).to be =~ "!\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
   end
 
   it "should provide a space CharSet" do
-    Chars::SPACE =~ "\t\n\v\f\r "
+    expect(described_class::SPACE).to be =~ "\t\n\v\f\r "
   end
 
   it "should provide a punctuation CharSet" do
-    Chars::PUNCTUATION =~ " !\"'(),-.:;?[]`{}~"
+    expect(described_class::PUNCTUATION).to be =~ " !\"'(),-.:;?[]`{}~"
   end
 
   it "should provide a symbols CharSet" do
-    Chars::SYMBOLS =~ " !\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
+    expect(described_class::SYMBOLS).to be =~ " !\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
   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'

metadata

@@ -1,64 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: chars
 version: !ruby/object:Gem::Version
-  version: 0.2.2
-  prerelease: 
+  version: 0.2.3
 platform: ruby
 authors:
 - Postmodern
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-28 00:00:00.000000000 Z
+date: 2020-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rubygems-tasks
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.4'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.7'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '2.0'
 description: Chars is a Ruby library for working with various character sets, recognizing
   text and generating random text from specific character sets.
 email: postmodern.mod3@gmail.com
@@ -69,12 +34,14 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
-- .document
-- .gemspec
-- .gitignore
-- .rspec
-- .yardopts
+- ".document"
+- ".gemspec"
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
 - ChangeLog.md
+- Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -97,26 +64,24 @@ files:
 homepage: https://github.com/postmodern/chars#readme
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 3.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A Ruby library for working with various character sets
 test_files: []