ronin-support 0.5.1 → 1.0.0.beta1

data/spec/extensions/kernel_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'ronin/extensions/kernel'
-
-describe Kernel do
-  it "should provide Kernel#try" do
-    Kernel.should respond_to('try')
-  end
-
-  describe "#try" do
-    it "should return the result of the block if nothing is raised" do
-      try { 2 + 2 }.should == 4
-    end
-
-    it "should return nil if an exception is raised" do
-      try { 2 + 'a' }.should be_nil
-    end
-
-    it "should rescue RuntimeError exceptions" do
-      lambda {
-        try { raise(RuntimeError,"something happened",caller) }
-      }.should_not raise_error(RuntimeError)
-    end
-
-    it "should rescue StandardError exceptions" do
-      lambda {
-        try { raise(StandardError,"not allowed to do that",caller) }
-      }.should_not raise_error(StandardError)
-    end
-  end
-end

data/spec/extensions/regexp_spec.rb

@@ -1,482 +0,0 @@
-require 'spec_helper'
-require 'ronin/extensions/regexp'
-
-describe Regexp do
-  describe "WORD" do
-    let(:word) { 'dog' }
-
-    subject { Regexp::WORD }
-
-    it "should not match single letters" do
-      subject.match('A').should be_nil
-    end
-
-    it "should not match numeric letters" do
-      subject.match("123#{word}123")[0].should == word
-    end
-
-    it "should not include ending periods" do
-      subject.match("#{word}.")[0].should == word
-    end
-
-    it "should not include leading punctuation" do
-      subject.match("'#{word}")[0].should == word
-    end
-
-    it "should not include tailing punctuation" do
-      subject.match("#{word}'")[0].should == word
-    end
-
-    it "should include punctuation in the middle of the word" do
-      name = "O'Brian"
-
-      subject.match(name)[0].should == name
-    end
-  end
-
-  describe "OCTET" do
-    subject { Regexp::OCTET }
-
-    it "should match 0 - 255" do
-      (0..255).all? { |n|
-        subject.match(n.to_s)[0] == n.to_s
-      }.should be_true
-    end
-
-    it "should not match numbers greater than 255" do
-      subject.match('256')[0].should == '25'
-    end
-  end
-
-  describe "MAC" do
-    subject { Regexp::MAC }
-
-    it "should match six hexadecimal bytes" do
-      mac = '12:34:56:78:9a:bc'
-
-      subject.match(mac)[0].should == mac
-    end
-  end
-
-  describe "IPv4" do
-    subject { Regexp::IPv4 }
-
-    it "should match valid addresses" do
-      ip = '127.0.0.1'
-
-      subject.match(ip)[0].should == ip
-    end
-
-    it "should match the Any address" do
-      ip = '0.0.0.0'
-
-      subject.match(ip)[0].should == ip
-    end
-
-    it "should match the broadcast address" do
-      ip = '255.255.255.255'
-
-      subject.match(ip)[0].should == ip
-    end
-
-    it "should match addresses with netmasks" do
-      ip = '10.1.1.1/24'
-
-      subject.match(ip)[0].should == ip
-    end
-
-    it "should not match addresses with octets > 255" do
-      ip = '10.1.256.1'
-
-      subject.match(ip).should be_nil
-    end
-
-    it "should not match addresses with more than three digits per octet" do
-      ip = '10.1111.1.1'
-
-      subject.match(ip).should be_nil
-    end
-  end
-
-  describe "IPv6" do
-    subject { Regexp::IPv6 }
-
-    it "should match valid IPv6 addresses" do
-      ip = '2001:db8:85a3:0:0:8a2e:370:7334'
-
-      subject.match(ip)[0].should == ip
-    end
-
-    it "should match IPv6 addresses with netmasks" do
-      ip = '2001:db8:1234::/48'
-
-      subject.match(ip)[0].should == ip
-    end
-
-    it "should match truncated IPv6 addresses" do
-      ip = '2001:db8:85a3::8a2e:370:7334'
-
-      subject.match(ip)[0].should == ip
-    end
-
-    it "should match IPv4-mapped IPv6 addresses" do
-      ip = '::ffff:192.0.2.128'
-
-      subject.match(ip)[0].should == ip
-    end
-  end
-
-  describe "IP" do
-    subject { Regexp::IP }
-
-    it "should match IPv4 addresses" do
-      ip = '10.1.1.1'
-
-      subject.match(ip)[0].should == ip
-    end
-
-    it "should match IPv6 addresses" do
-      ip = '2001:db8:85a3:0:0:8a2e:370:7334'
-
-      subject.match(ip)[0].should == ip
-    end
-  end
-
-  describe "HOST_NAME" do
-    subject { Regexp::HOST_NAME }
-
-    it "should match valid hostnames" do
-      hostname = 'www.google.com'
-
-      subject.match(hostname)[0].should == hostname
-    end
-
-    it "should not match hostnames without a TLD" do
-      subject.match('foo').should be_nil
-    end
-
-    it "should not match hostnames with unknown TLDs" do
-      subject.match('foo.zzz').should be_nil
-    end
-  end
-
-  describe "USER_NAME" do
-    subject { Regexp::USER_NAME }
-
-    it "should match valid user-names" do
-      username = 'alice1234'
-
-      subject.match(username)[0].should == username
-    end
-
-    it "should match user-names containing '_' characters" do
-      username = 'alice_1234'
-
-      subject.match(username)[0].should == username
-    end
-
-    it "should match user-names containing '.' characters" do
-      username = 'alice.1234'
-
-      subject.match(username)[0].should == username
-    end
-
-    it "should not match user-names beginning with numbers" do
-      subject.match('1234bob')[0].should == 'bob'
-    end
-
-    it "should not match user-names containing spaces" do
-      subject.match('alice eve')[0].should == 'alice'
-    end
-
-    it "should not match user-names containing other symbols" do
-      subject.match('alice^eve')[0].should == 'alice'
-    end
-  end
-
-  describe "EMAIL_ADDR" do
-    subject { Regexp::EMAIL_ADDR }
-
-    it "should match valid email addresses" do
-      email = 'alice@example.com'
-
-      subject.match(email)[0].should == email
-    end
-  end
-
-  describe "PHONE_NUMBER" do
-    subject { Regexp::PHONE_NUMBER }
-
-    it "should match 111-2222" do
-      number = '111-2222'
-
-      subject.match(number)[0].should == number
-    end
-
-    it "should match 111-2222x9" do
-      number = '111-2222x9'
-
-      subject.match(number)[0].should == number
-    end
-
-    it "should match 800-111-2222" do
-      number = '800-111-2222'
-
-      subject.match(number)[0].should == number
-    end
-
-    it "should match 1-800-111-2222" do
-      number = '1-800-111-2222'
-
-      subject.match(number)[0].should == number
-    end
-  end
-
-  describe "IDENTIFIER" do
-    subject { Regexp::IDENTIFIER }
-
-    it "should match Strings beginning with a '_' character" do
-      identifier = '_foo'
-
-      subject.match(identifier)[0].should == identifier
-    end
-
-    it "should match Strings ending with a '_' character" do
-      identifier = 'foo_'
-
-      subject.match(identifier)[0].should == identifier
-    end
-
-    it "should not match Strings beginning with numberic characters" do
-      subject.match('1234foo')[0].should == 'foo'
-    end
-
-    it "should not match Strings not containing any alpha characters" do
-      identifier = '_1234_'
-
-      subject.match(identifier).should be_nil
-    end
-  end
-
-  describe "FILE_EXT" do
-    subject { Regexp::FILE_EXT }
-
-    it "should match the '.' separator character" do
-      ext = '.txt'
-
-      subject.match(ext)[0].should == ext
-    end
-
-    it "should not allow '_' characters" do
-      subject.match('.foo_bar')[0].should == '.foo'
-    end
-
-    it "should not allow '-' characters" do
-      subject.match('.foo-bar')[0].should == '.foo'
-    end
-  end
-
-  describe "FILE_NAME" do
-    subject { Regexp::FILE_NAME }
-
-    it "should match file names" do
-      filename = 'foo_bar'
-
-      subject.match(filename)[0].should == filename
-    end
-
-    it "should match '\\' escapped characters" do
-      filename = 'foo\\ bar'
-
-      subject.match(filename)[0].should == filename
-    end
-  end
-
-  describe "FILE" do
-    subject { Regexp::FILE }
-
-    it "should match the filename and extension" do
-      filename = 'foo_bar.txt'
-
-      subject.match(filename)[0].should == filename
-    end
-  end
-
-  describe "DIRECTORY" do
-    subject { Regexp::DIRECTORY }
-
-    it "should match directory names" do
-      dir = 'foo_bar'
-
-      subject.match(dir)[0].should == dir
-    end
-
-    it "should match '.'" do
-      dir = '.'
-
-      subject.match(dir)[0].should == dir
-    end
-
-    it "should match '..'" do
-      dir = '..'
-
-      subject.match(dir)[0].should == dir
-    end
-  end
-
-  describe "RELATIVE_UNIX_PATH" do
-    subject { Regexp::RELATIVE_UNIX_PATH }
-
-    it "should match multiple directories" do
-      path = 'foo/./bar/../baz'
-
-      subject.match(path)[0].should == path
-    end
-  end
-
-  describe "ABSOLUTE_UNIX_PATH" do
-    subject { Regexp::ABSOLUTE_UNIX_PATH }
-
-    it "should match absolute paths" do
-      path = '/foo/bar/baz'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should match trailing '/' characters" do
-      path = '/foo/bar/baz/'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should not match relative directories" do
-      path = '/foo/./bar/../baz'
-
-      subject.match(path)[0].should == '/foo/'
-    end
-  end
-
-  describe "UNIX_PATH" do
-    subject { Regexp::UNIX_PATH }
-
-    it "should match relative paths" do
-      path = 'foo/./bar/../baz'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should match absolute paths" do
-      path = '/foo/bar/baz'
-
-      subject.match(path)[0].should == path
-    end
-  end
-
-  describe "RELATIVE_WINDOWS_PATH" do
-    subject { Regexp::RELATIVE_WINDOWS_PATH }
-
-    it "should match multiple directories" do
-      path = 'foo\\.\\bar\\..\\baz'
-
-      subject.match(path)[0].should == path
-    end
-  end
-
-  describe "ABSOLUTE_WINDOWS_PATH" do
-    subject { Regexp::ABSOLUTE_WINDOWS_PATH }
-
-    it "should match absolute paths" do
-      path = 'C:\\foo\\bar\\baz'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should match trailing '/' characters" do
-      path = 'C:\\foo\\bar\\baz\\'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should not match relative directories" do
-      path = 'C:\\foo\\.\\bar\\..\\baz'
-
-      subject.match(path)[0].should == 'C:\\foo\\'
-    end
-  end
-
-  describe "WINDOWS_PATH" do
-    subject { Regexp::WINDOWS_PATH }
-
-    it "should match relative paths" do
-      path = 'foo\\.\\bar\\..\\baz'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should match absolute paths" do
-      path = 'C:\\foo\\bar\\baz'
-
-      subject.match(path)[0].should == path
-    end
-  end
-
-  describe "RELATIVE_PATH" do
-    subject { Regexp::RELATIVE_PATH }
-
-    it "should match relative UNIX paths" do
-      path = 'foo/./bar/../baz'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should match relative Windows paths" do
-      path = 'foo\\.\\bar\\..\\baz'
-
-      subject.match(path)[0].should == path
-    end
-  end
-
-  describe "ABSOLUTE_PATH" do
-    subject { Regexp::ABSOLUTE_PATH }
-
-    it "should match absolute UNIX paths" do
-      path = '/foo/bar/baz'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should match absolute Windows paths" do
-      path = 'C:\\foo\\bar\\baz'
-
-      subject.match(path)[0].should == path
-    end
-  end
-
-  describe "PATH" do
-    subject { Regexp::PATH }
-
-    it "should match relative UNIX paths" do
-      path = 'foo/./bar/../baz'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should match absolute UNIX paths" do
-      path = '/foo/bar/baz'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should match relative Windows paths" do
-      path = 'foo\\.\\bar\\..\\baz'
-
-      subject.match(path)[0].should == path
-    end
-
-    it "should match absolute Windows paths" do
-      path = 'C:\\foo\\bar\\baz'
-
-      subject.match(path)[0].should == path
-    end
-  end
-end

data/spec/extensions/resolv_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-require 'ronin/extensions/resolv'
-
-describe Resolv do
-  describe "resolver" do
-    let(:nameserver) { '4.2.2.1' }
-
-    subject { Resolv }
-
-    it "should create a new Resolv::DNS object if a nameserver is given" do
-      subject.resolver(nameserver).should be_kind_of(Resolv::DNS)
-    end
-
-    it "should return the default resolver otherwise" do
-      subject.resolver.should == Resolv
-    end
-  end
-end

data/spec/extensions/string_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-require 'ronin/extensions/string'
-
-describe String do
-  describe "#each_substring" do
-    subject { 'hello' }
-
-    it "should enumerate over each sub-string within the String" do
-      subject.each_substring do |sub_string|
-        should include(sub_string)
-      end
-    end
-
-    it "should allow passing the string index back" do
-      subject.each_substring do |sub_string,index|
-        subject[index,sub_string.length].should == sub_string
-
-        should include(sub_string)
-      end
-    end
-
-    it "should enumerate over each sub-string of a minimum length" do
-      subject.each_substring(2) do |sub_string|
-        sub_string.length.should >= 2
-
-        should include(sub_string)
-      end
-    end
-
-    it "should return an Enumerator when no block is given" do
-      substrings = subject.each_substring
-      
-      substrings.all? { |sub_string|
-        subject.include?(sub_string)
-      }.should == true
-    end
-  end
-
-  describe "#each_unique_substring" do
-    subject { 'abablol' }
-
-    it "should enumerate over each unique sub-string within the String" do
-      seen = []
-
-      subject.each_unique_substring do |sub_string|
-        should include(sub_string)
-        seen.should_not include(sub_string)
-
-        seen << sub_string
-      end
-    end
-
-    it "should enumerate over each sub-string of a minimum length" do
-      seen = []
-
-      subject.each_unique_substring(2) do |sub_string|
-        sub_string.length.should >= 2
-
-        should include(sub_string)
-        seen.should_not include(sub_string)
-
-        seen << sub_string
-      end
-    end
-
-    it "should return an Enumerator when no block is given" do
-      seen = subject.each_unique_substring
-
-      seen.all? { |sub_string|
-        subject.include?(sub_string)
-      }.should == true
-
-      seen = seen.to_a
-      seen.uniq.should == seen
-    end
-  end
-
-  describe "#common_prefix" do
-    it "should find the common prefix between two Strings" do
-      one = 'What is puzzling you is the nature of my game'
-      two = 'What is puzzling you is the nature of my name'
-      common = 'What is puzzling you is the nature of my '
-
-      one.common_prefix(two).should == common
-    end
-
-    it "should return the common prefix between two Strings with no uncommon postfix" do
-      one = "1234"
-      two = "12345"
-      common = "1234"
-
-      one.common_prefix(two).should == common
-    end
-
-    it "should return an empty String if there is no common prefix" do
-      one = 'Tell me people'
-      two = 'Whats my name'
-
-      one.common_prefix(two).should == ''
-    end
-
-    it "should return an empty String if one of the strings is also empty" do
-      one = 'Haha'
-      two = ''
-
-      one.common_prefix(two).should == ''
-    end
-  end
-
-  describe "#common_suffix" do
-    it "should find the common postfix between two Strings" do
-      one = 'Tell me baby whats my name'
-      two = "Can't you guess my name"
-      common = 's my name'
-
-      one.common_suffix(two).should == common
-    end
-
-    it "should return an empty String if there is no common postfix" do
-      one = 'You got to right up, stand up'
-      two = 'stand up for your rights'
-
-      one.common_suffix(two).should == ''
-    end
-
-    it "should return an empty String if one of the strings is also empty" do
-      one = 'You and I must fight for our rights'
-      two = ''
-
-      one.common_suffix(two).should == ''
-    end
-  end
-
-  describe "#uncommon_substring" do
-    it "should find the uncommon substring between two Strings" do
-      one = "Tell me baby whats my name"
-      two = "Tell me honey whats my name"
-      uncommon = 'bab'
-
-      one.uncommon_substring(two).should == uncommon
-    end
-
-    it "should find the uncommon substring between two Strings with a common prefix" do
-      one = 'You and I must fight for our rights'
-      two = 'You and I must fight to survive'
-      uncommon = 'for our rights'
-
-      one.uncommon_substring(two).should == uncommon
-    end
-
-    it "should find the uncommon substring between two Strings with a common postfix" do
-      one = 'Tell me baby whats my name'
-      two = "Can't you guess my name"
-      uncommon = 'Tell me baby what'
-
-      one.uncommon_substring(two).should == uncommon
-    end
-  end
-
-  if RUBY_VERSION < '1.9.'
-    describe "#dump" do
-      it "should dump printable strings" do
-        "hello".dump.should == '"hello"'
-      end
-
-      it "should dump strings containing control characters" do
-        "hello\n\b\a".dump.should == '"hello\n\b\a"'
-      end
-
-      it "should dump strings containing non-printable characters" do
-        "hello\x90\x05\xEF".dump.should == '"hello\x90\x05\xEF"'
-      end
-
-      it "should dump the string when calling the inspect method" do
-        "hello\x90\x05\xEF".inspect.should == '"hello\x90\x05\xEF"'
-      end
-    end
-  end
-end