ronin-support 0.4.1 → 0.5.2

data/spec/path_spec.rb

@@ -7,45 +7,52 @@ describe Path do
   let(:n) { 7 }
 
   it "should inherit from Pathname" do
-    subject.superclass.should == Pathname
+    expect(subject.superclass).to eq(Pathname)
   end
 
-  it "should provide the root path" do
-    path = subject.root
+  describe "#initialize" do
+    it "should accept a separator argument" do
+      path = described_class.new('foo',"\\")
 
-    path.should.class == Path
-    path.to_s.should == '/'
+      expect(path.separator).to eq("\\")
+    end
+
+    it "should default the separator to File::SEPARATOR" do
+      path = described_class.new('foo')
+
+      expect(path.separator).to eq(File::SEPARATOR)
+    end
   end
 
   describe "up" do
     it "should be able to traverse up 0 directories" do
-      subject.up(0).should == File::SEPARATOR
+      expect(subject.up(0)).to eq(File::SEPARATOR)
     end
 
     it "should raise an ArgumentError when not passed an Integer or Enumerable" do
-      lambda {
+      expect {
         subject.up(1.5)
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     it "should raise an ArgumentError on negative number of directories" do
-      lambda {
+      expect {
         subject.up(-1)
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     it "should create directory-escaping paths" do
-      subject.up(n).to_s.should == (['..'] * n).join(File::SEPARATOR)
+      expect(subject.up(n).to_s).to eq((['..'] * n).join(File::SEPARATOR))
     end
 
     it "should create a range of directory-escaping paths" do
       range = 7..10
 
-      subject.up(range).should == range.map { |i| Path.up(i) }
+      expect(subject.up(range)).to eq(range.map { |i| Path.up(i) })
     end
 
     it "should allow using custom path separators" do
-      subject.up(n,'\\').to_s.should == (['..'] * n).join("\\")
+      expect(subject.up(n,'\\').to_s).to eq((['..'] * n).join("\\"))
     end
   end
 
@@ -56,31 +63,49 @@ describe Path do
       sub_path = File.join('one','two')
       expected = [subject, sub_path].join(File::SEPARATOR)
 
-      subject.join(sub_path).to_s.should == expected
+      expect(subject.join(sub_path).to_s).to eq(expected)
     end
 
     it "should join with a sub-directory" do
       sub_directory = 'three'
       expected = [subject, sub_directory].join(File::SEPARATOR)
 
-      subject.join(sub_directory).to_s.should == expected
+      expect(subject.join(sub_directory).to_s).to eq(expected)
     end
 
     it "should not collapse directory traversals" do
       traversal = Path.up(n)
       expected = [subject, traversal].join(File::SEPARATOR)
 
-      subject.join(traversal).to_s.should == expected
+      expect(subject.join(traversal).to_s).to eq(expected)
+    end
+
+    it "should filter out leading directory separators" do
+      expected = [subject, 'sub'].join(File::SEPARATOR)
+
+      expect(subject.join('/','sub','/').to_s).to eq(expected)
     end
 
     it "should filter out extra directory separators" do
       expected = [subject, 'sub'].join(File::SEPARATOR)
 
-      subject.join('/','sub','/').to_s.should == expected
+      expect(subject.join('/sub').to_s).to eq(expected)
     end
 
     it "should join with the root path" do
-      Path.root.join('etc','passwd').to_s.should == '/etc/passwd'
+      expect(Path.root.join('etc','passwd').to_s).to eq('/etc/passwd')
+    end
+
+    context "with a custom path seperator" do
+      let(:separator) { "\\" }
+
+      subject { described_class.new('foo',separator) }
+
+      it "should pass the path separator to the new path" do
+        new_path = subject.join('bar','baz')
+
+        expect(new_path.separator).to eq(separator)
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,7 +3,6 @@ require 'ronin/support/version'
 
 include Ronin
 
-RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.filter_run_excluding :network
+RSpec.configure do |specs|
+  specs.filter_run_excluding :network
 end

data/spec/support/inflector_spec.rb

@@ -5,18 +5,18 @@ describe "Ronin::Support::Inflector" do
   subject { Ronin::Support::Inflector }
 
   it "should not be nil" do
-    subject.should_not be_nil
+    expect(subject).not_to be_nil
   end
 
   it "should support pluralizing words" do
-    subject.pluralize('word').should == 'words'
+    expect(subject.pluralize('word')).to eq('words')
   end
 
   it "should support singularizing words" do
-    subject.singularize('words').should == 'word'
+    expect(subject.singularize('words')).to eq('word')
   end
 
   it "should support humanizing words" do
-    subject.humanize('word_id').should == 'Word'
+    expect(subject.humanize('word_id')).to eq('Word')
   end
 end

data/spec/support_spec.rb

@@ -3,6 +3,6 @@ require 'ronin/support/version'
 
 describe Support do
   it "should have a version" do
-    subject.const_defined?('VERSION').should == true
+    expect(subject.const_defined?('VERSION')).to be(true)
   end
 end

data/spec/templates/erb_spec.rb

@@ -6,16 +6,16 @@ require 'templates/classes/example_erb'
 describe Templates::Erb do
   subject { ExampleErb.new }
 
-  before(:all) do
+  before do
     subject.x = 2
     subject.y = 3
   end
 
   it "should render inline ERB templates" do
-    subject.erb(%{<%= 'hello' %>}).should == 'hello'
+    expect(subject.erb(%{<%= 'hello' %>})).to eq('hello')
   end
 
   it "should render ERB templates using the binding of the object" do
-    subject.erb(%{<%= @x %> <%= @y %>}).should == '2 3'
+    expect(subject.erb(%{<%= @x %> <%= @y %>})).to eq('2 3')
   end
 end

data/spec/templates/template_spec.rb

@@ -11,44 +11,44 @@ describe Templates::Template do
   subject { ExampleTemplate.new }
 
   it "should return the result of the block when entering a template" do
-    subject.enter_example_template { |path|
+    expect(subject.enter_example_template { |path|
       'result'
-    }.should == 'result'
+    }).to eq('result')
   end
 
   it "should be able to find templates relative to the current one" do
     subject.enter_example_template do |path|
-      path.should == example_template
+      expect(path).to eq(example_template)
     end
   end
 
   it "should be able to find static templates" do
     subject.enter_relative_template do |path|
-      path.should == relative_template
+      expect(path).to eq(relative_template)
     end
   end
 
   it "should raise a RuntimeError when entering an unknown template" do
-    lambda {
+    expect {
       subject.enter_missing_template { |path| }
-    }.should raise_error(RuntimeError)
+    }.to raise_error(RuntimeError)
   end
 
   it "should be able to read templates relative to the current one" do
     subject.read_example_template do |contents|
-      contents.should == File.read(example_template)
+      expect(contents).to eq(File.read(example_template))
     end
   end
 
   it "should be able to find static templates" do
     subject.read_relative_template do |contents|
-      contents.should == File.read(relative_template)
+      expect(contents).to eq(File.read(relative_template))
     end
   end
 
   it "should raise a RuntimeError when entering an unknown template" do
-    lambda {
+    expect {
       subject.read_missing_template { |path| }
-    }.should raise_error(RuntimeError)
+    }.to raise_error(RuntimeError)
   end
 end

data/spec/ui/shell_spec.rb

@@ -13,7 +13,7 @@ describe UI::Shell do
 
       shell.call(line)
 
-      lines.should == [line]
+      expect(lines).to eq([line])
     end
   end
 
@@ -22,11 +22,11 @@ describe UI::Shell do
 
     describe "#commands" do
       it "should include builtin methods" do
-        subject.commands.should include('help', 'exit')
+        expect(subject.commands).to include('help', 'exit')
       end
 
       it "should include protected methods" do
-        subject.commands.should include(
+        expect(subject.commands).to include(
           'command1',
           'command_with_arg',
           'command_with_args'
@@ -34,49 +34,49 @@ describe UI::Shell do
       end
 
       it "should not include public methods" do
-        subject.commands.should_not include('a_public_method')
+        expect(subject.commands).not_to include('a_public_method')
       end
     end
 
     describe "#call" do
       it "should ignore empty lines" do
-        subject.call('').should == false
+        expect(subject.call('')).to be(false)
       end
 
       it "should ignore white-space lines" do
-        subject.call("     \t   ").should == false
+        expect(subject.call("     \t   ")).to be(false)
       end
 
       it "should not allow calling the handler method" do
-        subject.call('handler').should == false
+        expect(subject.call('handler')).to be(false)
       end
 
       it "should not allow calling unknown commands" do
-        subject.call('an_unknown_command').should == false
+        expect(subject.call('an_unknown_command')).to be(false)
       end
 
       it "should not allow calling unknown commands" do
-        subject.call('an_unknown_command').should == false
+        expect(subject.call('an_unknown_command')).to be(false)
       end
 
       it "should not allow calling public methods" do
-        subject.call('a_public_method').should == false
+        expect(subject.call('a_public_method')).to be(false)
       end
 
       it "should allow calling protected methods" do
-        subject.call('command1').should == :command1
+        expect(subject.call('command1')).to eq(:command1)
       end
 
       it "should raise an exception when passing invalid number of arguments" do
-        lambda {
+        expect {
           subject.call('command_with_arg too many args')
-        }.should raise_error(ArgumentError)
+        }.to raise_error(ArgumentError)
       end
 
       it "should splat the command arguments to the command method" do
-        subject.call('command_with_args one two three').should == [
+        expect(subject.call('command_with_args one two three')).to eq([
           'one', 'two', 'three'
-        ]
+        ])
       end
     end
   end

data/spec/wordlist_spec.rb

@@ -1,16 +1,15 @@
 require 'spec_helper'
 require 'ronin/wordlist'
 
-require 'tempfile'
+require 'tmpdir'
 
 describe Wordlist do
   let(:words) { %w[foo bar baz] }
+  let(:path)  { File.join(Dir.tmpdir,'ronin-support-wordlist') }
 
-  before(:all) do
-    Tempfile.open('ronin-support-wordlist') do |file|
-      words.each { |word| file.puts word }
-
-      @path = file.path
+  before do
+    File.open(path,'w') do |file|
+      file.puts(*words)
     end
   end
 
@@ -37,29 +36,74 @@ describe Wordlist do
 
       subject.parse(text) { |word| seen << word }
 
-      seen.should =~ words
+      expect(seen).to match_array(words)
+    end
+  end
+
+  describe "create" do
+    let(:created_path) { File.join(Dir.tmpdir,'ronin-support-created-wordlist') }
+    let(:text) { words.join(' ') }
+
+    it "should return the new Wordlist object" do
+      wordlist = described_class.create(created_path,text)
+
+      expect(wordlist.to_a).to match_array(words)
+    end
+
+    it "should create a wordlist file from text" do
+      described_class.create(created_path,text)
+
+      saved_words = File.open(created_path).each_line.map(&:chomp)
+
+      expect(saved_words).to match_array(words)
+    end
+
+    it "should apply mutations to the created wordlist" do
+      described_class.create(created_path,text, 'o' => ['0'])
+
+      saved_words = File.open(created_path).each_line.map(&:chomp)
+
+      expect(saved_words).to match_array(%w[foo f0o fo0 f00 bar baz])
     end
+
+    after { FileUtils.rm(created_path) }
   end
 
   describe "#initialize" do
     it "should accept a list of words" do
-      subject.to_a.should == words
+      wordlist = described_class.new(path)
+
+      expect(wordlist.to_a).to eq(words)
     end
 
     it "should accept a path to a wordlist file" do
-      file = described_class.new(@path)
+      wordlist = described_class.new(path)
 
-      file.to_a.should == words
+      expect(wordlist.to_a).to eq(words)
+    end
+
+    it "should raise a TypeError for non-String / non-Enumerable objects" do
+      expect {
+        described_class.new(Object.new)
+      }.to raise_error(TypeError)
     end
   end
 
   describe "#each_word" do
-    it "should raise a TypeError for non-String / non-Enumerable objects" do
-      wordlist = described_class.new(Object.new)
+    context "with wordlist file" do
+      subject { described_class.new(path) }
 
-      lambda {
-        wordlist.each_word { |word| }
-      }.should raise_error(TypeError)
+      it "should enumerate over the words" do
+        expect(subject.each_word.to_a).to eq(words)
+      end
+    end
+
+    context "with words" do
+      subject { described_class.new(words) }
+
+      it "should enumerate over the words" do
+        expect(subject.each_word.to_a).to eq(words)
+      end
     end
   end
 
@@ -67,24 +111,41 @@ describe Wordlist do
     it "should rewind file lists" do
       subject.each { |word| }
 
-      subject.to_a.should == words
+      expect(subject.to_a).to eq(words)
     end
 
     it "should apply additional mutation rules" do
       wordlist = described_class.new(words)
       wordlist.mutations['o'] = ['0']
 
-      wordlist.to_a.should =~ %w[foo f0o fo0 f00 bar baz]
+      expect(wordlist.to_a).to match_array(%w[foo f0o fo0 f00 bar baz])
     end
   end
 
   describe "#each_n_words" do
     it "should enumerate over every combination of N words" do
-      subject.each_n_words(2).to_a.should == %w[
+      expect(subject.each_n_words(2).to_a).to eq(%w[
         foofoo foobar foobaz
         barfoo barbar barbaz
         bazfoo bazbar bazbaz
-      ]
+      ])
     end
   end
+
+  describe "#save" do
+    let(:saved_path) { File.join(Dir.tmpdir,'ronin-support-saved-wordlist') }
+
+    it "should save the words with mutations to a file" do
+      subject.save(saved_path)
+
+      saved_words    = File.open(saved_path).each_line.map(&:chomp)
+      expected_words = subject.to_a
+
+      expect(saved_words).to eq(expected_words)
+    end
+
+    after { FileUtils.rm(saved_path) }
+  end
+
+  after { FileUtils.rm(path) }
 end