wordlist 0.1.1 → 1.0.0

data/spec/compression/reader_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require 'wordlist/compression/reader'
+
+describe Wordlist::Compression::Reader do
+  describe ".command" do
+    let(:path) { 'path/to/file' }
+
+    context "when given format: :gzip" do
+      subject { described_class.command(path, format: :gzip) }
+
+      it "must return 'zcat path/to/file'" do
+        expect(subject).to eq("zcat #{path}")
+      end
+
+      context "and the file contains special characters" do
+        let(:path) { 'path/to/the file' }
+
+        it "must shellescape them" do
+          expect(subject).to eq("zcat #{Shellwords.shellescape(path)}")
+        end
+      end
+    end
+
+    context "when given format: :bzip2" do
+      subject { described_class.command(path, format: :bzip2) }
+
+      it "must return 'bzcat path/to/file'" do
+        expect(subject).to eq("bzcat #{path}")
+      end
+
+      context "and the file contains special characters" do
+        let(:path) { 'path/to/the file' }
+
+        it "must shellescape them" do
+          expect(subject).to eq("bzcat #{Shellwords.shellescape(path)}")
+        end
+      end
+    end
+
+    context "when given format: :xz" do
+      subject { described_class.command(path, format: :xz) }
+
+      it "must return 'xzcat path/to/file'" do
+        expect(subject).to eq("xzcat #{path}")
+      end
+
+      context "and the file contains special characters" do
+        let(:path) { 'path/to/the file' }
+
+        it "must shellescape them" do
+          expect(subject).to eq("xzcat #{Shellwords.shellescape(path)}")
+        end
+      end
+    end
+
+    context "when given an unknown format: value" do
+      let(:format) { :foo }
+
+      it do
+        expect {
+          subject.command(path, format: format)
+        }.to raise_error(Wordlist::UnknownFormat,"unsupported format: #{format.inspect}")
+      end
+    end
+  end
+
+  describe ".open" do
+    let(:fixtures_dir) { ::File.join(__dir__,'..','fixtures') }
+
+    context "when given format: :gzip" do
+      let(:path) { ::File.join(fixtures_dir,'wordlist.txt.gz') }
+      let(:expected_contents) { `zcat #{Shellwords.shellescape(path)}` }
+
+      subject { described_class.open(path, format: :gzip) }
+
+      it "must return an IO object" do
+        expect(subject).to be_kind_of(IO)
+      end
+
+      context "when read from" do
+        it "must read the uncompressed contents of the wordllist" do
+          expect(subject.read).to eq(expected_contents)
+        end
+      end
+    end
+
+    context "when given format: :bzip2" do
+      let(:path) { ::File.join(fixtures_dir,'wordlist.txt.bz2') }
+      let(:expected_contents) { `bzcat #{Shellwords.shellescape(path)}` }
+
+      subject { described_class.open(path, format: :bzip2) }
+
+      it "must return an IO object" do
+        expect(subject).to be_kind_of(IO)
+      end
+
+      context "when read from" do
+        it "must read the uncompressed contents of the wordllist" do
+          expect(subject.read).to eq(expected_contents)
+        end
+      end
+    end
+
+    context "when given format: :xz" do
+      let(:path) { ::File.join(fixtures_dir,'wordlist.txt.xz') }
+      let(:expected_contents) { `xzcat #{Shellwords.shellescape(path)}` }
+
+      subject { described_class.open(path, format: :xz) }
+
+      it "must return an IO object" do
+        expect(subject).to be_kind_of(IO)
+      end
+
+      context "when read from" do
+        it "must read the uncompressed contents of the wordllist" do
+          expect(subject.read).to eq(expected_contents)
+        end
+      end
+    end
+
+    context "when the command is not installed" do
+      let(:format)  { :gzip  }
+      let(:command) { Shellwords.shelljoin(['zcat', path]) }
+      let(:path)    { 'path/to/wordlist.gz' }
+
+      before do
+        expect(IO).to receive(:popen).with(command).and_raise(Errno::ENOENT)
+      end
+
+      it do
+        expect {
+          described_class.open(path, format: format)
+        }.to raise_error(Wordlist::CommandNotFound,"#{command.inspect} command not found")
+      end
+    end
+  end
+end

data/spec/compression/writer_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+require 'wordlist/compression/writer'
+
+require 'fileutils'
+
+describe Wordlist::Compression::Writer do
+  describe ".command" do
+    let(:path) { 'path/to/file' }
+
+    context "when given format: :gzip" do
+      subject { described_class.command(path, format: :gzip) }
+
+      it "must return 'gzip > path/to/file'" do
+        expect(subject).to eq("gzip > #{path}")
+      end
+
+      context "and given append: true" do
+        subject { described_class.command(path, format: :gzip, append: true) }
+
+        it "must return 'gzip >> path/to/file'" do
+          expect(subject).to eq("gzip >> #{path}")
+        end
+      end
+
+      context "and the file contains special characters" do
+        let(:path) { 'path/to/the file' }
+
+        it "must shellescape them" do
+          expect(subject).to eq("gzip > #{Shellwords.shellescape(path)}")
+        end
+      end
+    end
+
+    context "when given format: :bzip2" do
+      subject { described_class.command(path, format: :bzip2) }
+
+      it "must return 'bzip2 > path/to/file'" do
+        expect(subject).to eq("bzip2 > #{path}")
+      end
+
+      context "and given append: true" do
+        subject { described_class.command(path, format: :bzip2, append: true) }
+
+        it "must return 'bzip2 >> path/to/file'" do
+          expect(subject).to eq("bzip2 >> #{path}")
+        end
+      end
+
+      context "and the file contains special characters" do
+        let(:path) { 'path/to/the file' }
+
+        it "must shellescape them" do
+          expect(subject).to eq("bzip2 > #{Shellwords.shellescape(path)}")
+        end
+      end
+    end
+
+    context "when given format: :xz" do
+      subject { described_class.command(path, format: :xz) }
+
+      it "must return 'xz > path/to/file'" do
+        expect(subject).to eq("xz > #{path}")
+      end
+
+      context "and given append: true" do
+        subject { described_class.command(path, format: :xz, append: true) }
+
+        it "must return 'xz >> path/to/file'" do
+          expect(subject).to eq("xz >> #{path}")
+        end
+      end
+
+      context "and the file contains special characters" do
+        let(:path) { 'path/to/the file' }
+
+        it "must shellescape them" do
+          expect(subject).to eq("xz > #{Shellwords.shellescape(path)}")
+        end
+      end
+    end
+
+    context "when given an unknown format: value" do
+      let(:format) { :foo }
+
+      it do
+        expect {
+          subject.command(path, format: format)
+        }.to raise_error(Wordlist::UnknownFormat,"unsupported format: #{format.inspect}")
+      end
+    end
+  end
+
+  describe ".open" do
+    let(:fixtures_dir) { ::File.join(__dir__,'..','fixtures') }
+
+    let(:words) { %w[foo bar] }
+
+    context "when given format: :gzip" do
+      let(:path) { ::File.join(fixtures_dir,'new_wordlist.txt.gz') }
+
+      subject { described_class.open(path, format: :gzip) }
+
+      it "must return an IO object" do
+        expect(subject).to be_kind_of(IO)
+      end
+
+      context "when written to" do
+        before do
+          subject.puts words
+          subject.close
+        end
+
+        let(:written_contents) { `zcat #{Shellwords.shellescape(path)}` }
+        let(:written_words)    { written_contents.lines.map(&:chomp)    }
+
+        it "must writing gzip compressed data to the file" do
+          expect(written_words).to eq(words)
+        end
+      end
+
+      after { ::FileUtils.rm_f(path) }
+    end
+
+    context "when given format: :bzip2" do
+      let(:path) { ::File.join(fixtures_dir,'new_wordlist.txt.bz2') }
+
+      subject { described_class.open(path, format: :bzip2) }
+
+      it "must return an IO object" do
+        expect(subject).to be_kind_of(IO)
+      end
+
+      context "when written to" do
+        before do
+          subject.puts words
+          subject.close
+        end
+
+        let(:written_contents) { `bzcat #{Shellwords.shellescape(path)}` }
+        let(:written_words)    { written_contents.lines.map(&:chomp)    }
+
+        it "must writing bzip2 compressed data to the file" do
+          expect(written_words).to eq(words)
+        end
+      end
+
+      after { ::FileUtils.rm_f(path) }
+    end
+
+    context "when given format: :xz" do
+      let(:path) { ::File.join(fixtures_dir,'new_wordlist.txt.xz') }
+
+      subject { described_class.open(path, format: :xz) }
+
+      it "must return an IO object" do
+        expect(subject).to be_kind_of(IO)
+      end
+
+      context "when written to" do
+        before do
+          subject.puts words
+          subject.close
+        end
+
+        let(:written_contents) { `xzcat #{Shellwords.shellescape(path)}` }
+        let(:written_words)    { written_contents.lines.map(&:chomp)    }
+
+        it "must writing xz compressed data to the file" do
+          expect(written_words).to eq(words)
+        end
+      end
+
+      after { ::FileUtils.rm_f(path) }
+    end
+
+    context "when the command is not installed" do
+      let(:format)  { :gzip  }
+      let(:command) { "gzip > #{Shellwords.shellescape(path)}" }
+      let(:path)    { ::File.join(fixtures_dir,'new_wordlist.txt.gz') }
+
+      before do
+        expect(IO).to receive(:popen).with(command,'w').and_raise(Errno::ENOENT)
+      end
+
+      it do
+        expect {
+          described_class.open(path, format: format)
+        }.to raise_error(Wordlist::CommandNotFound,"#{command.inspect} command not found")
+      end
+
+      after { ::FileUtils.rm_f(path) }
+    end
+  end
+end

data/spec/file_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+require 'wordlist/file'
+
+describe Wordlist::File do
+  let(:fixtures_dir) { ::File.join(__dir__,'fixtures') }
+  let(:path) { ::File.join(fixtures_dir,'wordlist.txt') }
+
+  subject { described_class.new(path) }
+
+  describe "#initialize" do
+    it "must set #path" do
+      expect(subject.path).to eq(path)
+    end
+
+    context "when initialized with non-existant path" do
+      let(:path) { '/does/not/exist.txt' }
+
+      it do
+        expect {
+          described_class.new(path)
+        }.to raise_error(Wordlist::WordlistNotFound,"wordlist file does not exist: #{path.inspect}")
+      end
+    end
+
+    context "when given a relative path" do
+      let(:relative_path) { ::File.join(__FILE__,"../fixtures/wordlist.txt") }
+      
+      subject { described_class.new(relative_path) }
+
+      it "must expand the given path" do
+        expect(subject.path).to eq(::File.expand_path(relative_path))
+      end
+    end
+
+    context "when format: is not given" do
+      context "and the path ends in .txt" do
+        let(:path) { ::File.join(fixtures_dir,'wordlist.txt') }
+
+        it "must set #format to :txt" do
+          expect(subject.format).to eq(:txt)
+        end
+      end
+
+      context "and the path ends in .gz" do
+        let(:path) { ::File.join(fixtures_dir,'wordlist.txt.gz') }
+
+        it "must set #format to :gzip" do
+          expect(subject.format).to eq(:gzip)
+        end
+      end
+
+      context "and the path ends in .bz2" do
+        let(:path) { ::File.join(fixtures_dir,'wordlist.txt.bz2') }
+
+        it "must set #format to :bzip2" do
+          expect(subject.format).to eq(:bzip2)
+        end
+      end
+
+      context "and the path ends in .xz" do
+        let(:path) { ::File.join(fixtures_dir,'wordlist.txt.xz') }
+
+        it "must set #format to :xz" do
+          expect(subject.format).to eq(:xz)
+        end
+      end
+    end
+
+    context "when format: is given" do
+      let(:format) { :gzip }
+
+      subject { described_class.new(path, format: format) }
+
+      it "must set #format" do
+        expect(subject.format).to eq(format)
+      end
+
+      context "but it's an unknown format" do
+        let(:format) { :foo }
+
+        it do
+          expect {
+            described_class.new(path, format: format)
+          }.to raise_error(Wordlist::UnknownFormat,"unknown format given: #{format.inspect}")
+        end
+      end
+    end
+  end
+
+  describe ".open" do
+    subject { described_class.open(path) }
+
+    it { expect(subject).to be_kind_of(described_class) }
+
+    it "must initialize #path" do
+      expect(subject.path).to eq(path)
+    end
+  end
+
+  let(:expected_contents) { ::File.read(path) }
+  let(:expected_lines)    { expected_contents.lines }
+  let(:expected_words)    { expected_lines.map(&:chomp) }
+
+  describe ".read" do
+    subject { described_class }
+
+    it "must open the wordlist and enumerate over each word" do
+      expect { |b|
+        subject.read(path,&b)
+      }.to yield_successive_args(*expected_words)
+    end
+  end
+
+  describe "#each_line" do
+    context "when given a block" do
+      it "must yield each read line of the file" do
+        expect { |b|
+          subject.each_line(&b)
+        }.to yield_successive_args(*expected_lines)
+      end
+
+      context "and the wordlist format is gzip" do
+        let(:path) { ::File.join(fixtures_dir,'wordlist.txt.gz') }
+        let(:expected_contents) { `zcat #{Shellwords.shellescape(path)}` }
+
+        it "must read the uncompressed gzip data" do
+          expect { |b|
+            subject.each_line(&b)
+          }.to yield_successive_args(*expected_lines)
+        end
+      end
+
+      context "and the wordlist format is bzip2" do
+        let(:path) { ::File.join(fixtures_dir,'wordlist.txt.bz2') }
+        let(:expected_contents) { `bzcat #{Shellwords.shellescape(path)}` }
+
+        it "must read the uncompressed gzip data" do
+          expect { |b|
+            subject.each_line(&b)
+          }.to yield_successive_args(*expected_lines)
+        end
+      end
+
+      context "and the wordlist format is xz" do
+        let(:path) { ::File.join(fixtures_dir,'wordlist.txt.xz') }
+        let(:expected_contents) { `xzcat #{Shellwords.shellescape(path)}` }
+
+        it "must read the uncompressed gzip data" do
+          expect { |b|
+            subject.each_line(&b)
+          }.to yield_successive_args(*expected_lines)
+        end
+      end
+    end
+
+    context "when not given a block" do
+      it "must return an Enumerator" do
+        expect(subject.each_line).to be_kind_of(Enumerator)
+        expect(subject.each_line.to_a).to eq(expected_lines)
+      end
+
+      context "and the wordlist format is gzip" do
+        let(:path) { ::File.join(fixtures_dir,'wordlist.txt.gz') }
+        let(:expected_contents) { `zcat #{Shellwords.shellescape(path)}` }
+
+        it "must return an Enumerator of the uncompressed gzip data" do
+          expect(subject.each_line).to be_kind_of(Enumerator)
+          expect(subject.each_line.to_a).to eq(expected_lines)
+        end
+      end
+
+      context "and the wordlist format is bzip2" do
+        let(:path) { ::File.join(fixtures_dir,'wordlist.txt.bz2') }
+        let(:expected_contents) { `bzcat #{Shellwords.shellescape(path)}` }
+
+        it "must return an Enumerator of the compressed gzip data" do
+          expect(subject.each_line).to be_kind_of(Enumerator)
+          expect(subject.each_line.to_a).to eq(expected_lines)
+        end
+      end
+
+      context "and the wordlist format is xz" do
+        let(:path) { ::File.join(fixtures_dir,'wordlist.txt.xz') }
+        let(:expected_contents) { `xzcat #{Shellwords.shellescape(path)}` }
+
+        it "must return an Enumerator of the compressed gzip data" do
+          expect(subject.each_line).to be_kind_of(Enumerator)
+          expect(subject.each_line.to_a).to eq(expected_lines)
+        end
+      end
+    end
+  end
+
+  describe "#each" do
+    it "must yield each word on each line" do
+      expect { |b|
+        subject.each(&b)
+      }.to yield_successive_args(*expected_words)
+    end
+
+    context "and the wordlist format is gzip" do
+      let(:path) { ::File.join(fixtures_dir,'wordlist.txt.gz') }
+      let(:expected_contents) { `zcat #{Shellwords.shellescape(path)}` }
+
+      it "must read the uncompressed gzip data" do
+        expect { |b|
+          subject.each_line(&b)
+        }.to yield_successive_args(*expected_lines)
+      end
+    end
+
+    context "and the wordlist format is bzip2" do
+      let(:path) { ::File.join(fixtures_dir,'wordlist.txt.bz2') }
+      let(:expected_contents) { `bzcat #{Shellwords.shellescape(path)}` }
+
+      it "must read the uncompressed gzip data" do
+        expect { |b|
+          subject.each_line(&b)
+        }.to yield_successive_args(*expected_lines)
+      end
+    end
+
+    context "and the wordlist format is xz" do
+      let(:path) { ::File.join(fixtures_dir,'wordlist.txt.xz') }
+      let(:expected_contents) { `xzcat #{Shellwords.shellescape(path)}` }
+
+      it "must read the uncompressed gzip data" do
+        expect { |b|
+          subject.each_line(&b)
+        }.to yield_successive_args(*expected_lines)
+      end
+    end
+
+    context "when the wordlist contains empty lines" do
+      let(:expected_words) do
+        super().reject { |w| w.empty? }
+      end
+
+      it "must omit empty lines" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*expected_words)
+      end
+    end
+
+    context "when the wordlist contains comment lines" do
+      let(:expected_words) do
+        super().reject { |w| w.start_with?('#') }
+      end
+
+      it "must omit lines beginning with a '#'" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*expected_words)
+      end
+    end
+  end
+end

data/spec/fixtures/wordlist.txt

@@ -0,0 +1,15 @@
+foo
+bar
+baz
+qux
+quux
+quuz
+corge
+grault
+garply
+waldo
+fred
+plugh
+plugh
+xyzzy
+thud

data/spec/fixtures/wordlist_with_ambiguous_format

@@ -0,0 +1,3 @@
+foo
+bar
+baz

data/spec/fixtures/wordlist_with_comments.txt

@@ -0,0 +1,19 @@
+foo
+bar
+baz
+qux
+# comment1
+quux
+quuz
+corge
+grault
+# comment2
+#
+# comment3
+garply
+waldo
+fred
+plugh
+plugh
+xyzzy
+thud

data/spec/fixtures/wordlist_with_empty_lines.txt

@@ -0,0 +1,19 @@
+foo
+bar
+baz
+qux
+quux
+
+quuz
+corge
+grault
+garply
+waldo
+
+
+fred
+plugh
+plugh
+xyzzy
+thud
+

data/spec/format_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'wordlist/format'
+
+describe Wordlist::Format do
+  describe ".infer" do
+    context "when given a path ending in '.txt'" do
+      it "must return :txt" do
+        expect(subject.infer("path/to/file.txt")).to eq(:txt)
+      end
+    end
+
+    context "when given a path ending in '.gz'" do
+      it "must return :gzip" do
+        expect(subject.infer("path/to/file.gz")).to eq(:gzip)
+      end
+    end
+
+    context "when given a path ending in '.bz2'" do
+      it "must return :bzip2" do
+        expect(subject.infer("path/to/file.bz2")).to eq(:bzip2)
+      end
+    end
+
+    context "when given a path ending in '.xz'" do
+      it "must return :xz" do
+        expect(subject.infer("path/to/file.xz")).to eq(:xz)
+      end
+    end
+
+    context "when given a path ending in another file extension" do
+      let(:path) { "path/to/file.foo" }
+
+      it do
+        expect {
+          subject.infer(path)
+        }.to raise_error(Wordlist::UnknownFormat,"could not infer the format of file: #{path.inspect}")
+      end
+    end
+
+    context "when given a path has no file extension" do
+      let(:path) { "path/to/file" }
+
+      it do
+        expect {
+          subject.infer(path)
+        }.to raise_error(Wordlist::UnknownFormat,"could not infer the format of file: #{path.inspect}")
+      end
+    end
+  end
+end