recog 3.1.1 → 3.1.2

data/spec/lib/recog/db_spec.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'recog/db'
 
 describe Recog::DB do
-
-  describe "#fingerprints" do
-    context "with inline example content" do
+  describe '#fingerprints' do
+    context 'with inline example content' do
       let(:xml_file) { File.expand_path File.join('spec', 'data', 'test_fingerprints.xml') }
       subject { Recog::DB.new(xml_file) }
 
@@ -11,50 +12,50 @@ describe Recog::DB do
 
       it { is_expected.to be_a(Enumerable) }
 
-      context "with only a pattern" do
+      context 'with only a pattern' do
         subject(:entry) { described_class.new(xml_file).fingerprints[0] }
 
-        it "has a blank name with no description" do
+        it 'has a blank name with no description' do
           expect(entry.name).to be_empty
         end
 
-        it "has a pattern" do
-          expect(entry.regex.source).to eq(".*\\(iSeries\\).*")
+        it 'has a pattern' do
+          expect(entry.regex.source).to eq('.*\\(iSeries\\).*')
         end
 
-        it "has no params" do
+        it 'has no params' do
           expect(entry.params).to be_empty
         end
 
-        it "has no tests" do
+        it 'has no tests' do
           expect(entry.tests).to be_empty
         end
       end
 
-      context "with params" do
+      context 'with params' do
         subject(:entry) { described_class.new(xml_file).fingerprints[1] }
 
-        it "has a name" do
+        it 'has a name' do
           expect(entry.name).to eq('PalmOS')
         end
 
-        it "has a pattern" do
-          expect(entry.regex.source).to eq(".*\\(PalmOS\\).*")
+        it 'has a pattern' do
+          expect(entry.regex.source).to eq('.*\\(PalmOS\\).*')
         end
 
-        it "has params" do
-          expect(entry.params).to eq({"os.vendor"=>[1, "Palm"], "os.device"=>[2, "General"]})
+        it 'has params' do
+          expect(entry.params).to eq({ 'os.vendor' => [1, 'Palm'], 'os.device' => [2, 'General'] })
         end
 
-        it "has no tests" do
+        it 'has no tests' do
           expect(entry.tests).to be_empty
         end
       end
 
-      context "with pattern flags" do
+      context 'with pattern flags' do
         subject(:entry) { described_class.new(xml_file).fingerprints[2] }
 
-        it "has a name and only uses the first value" do
+        it 'has a name and only uses the first value' do
           expect(entry.name).to eq('HP Designjet printer')
         end
 
@@ -63,57 +64,57 @@ describe Recog::DB do
           expect(entry.regex.options).to eq(Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::IGNORECASE)
         end
 
-        it "has a pattern" do
+        it 'has a pattern' do
           expect(entry.regex).to be_a(Regexp)
-          expect(entry.regex.source).to eq("(designjet \\S+)")
+          expect(entry.regex.source).to eq('(designjet \\S+)')
         end
 
-        it "has params" do
-          expect(entry.params).to eq({"service.vendor"=>[0, "HP"]})
+        it 'has params' do
+          expect(entry.params).to eq({ 'service.vendor' => [0, 'HP'] })
         end
 
-        it "has no tests" do
+        it 'has no tests' do
           expect(entry.tests).to be_empty
         end
       end
 
-      context "with test" do
+      context 'with test' do
         subject(:entry) { described_class.new(xml_file).fingerprints[3] }
 
-        it "has a name" do
+        it 'has a name' do
           expect(entry.name).to eq('HP JetDirect Printer')
         end
 
-        it "has a pattern" do
-          expect(entry.regex.source).to eq("laserjet (.*)(?: series)?")
+        it 'has a pattern' do
+          expect(entry.regex.source).to eq('laserjet (.*)(?: series)?')
         end
 
-        it "has params" do
-          expect(entry.params).to eq({"service.vendor"=>[0, "HP"]})
+        it 'has params' do
+          expect(entry.params).to eq({ 'service.vendor' => [0, 'HP'] })
         end
 
-        it "has tests" do
-          expect(entry.tests.map(&:content)).to match_array(["HP LaserJet 4100 Series", "HP LaserJet 2200"])
+        it 'has tests' do
+          expect(entry.tests.map(&:content)).to match_array(['HP LaserJet 4100 Series', 'HP LaserJet 2200'])
         end
       end
     end
 
-    context "with external example content" do
+    context 'with external example content' do
       let(:xml_file) { File.expand_path File.join('spec', 'data', 'external_example_fingerprint.xml') }
       subject { Recog::DB.new(xml_file) }
 
       subject(:entry) { described_class.new(xml_file).fingerprints[0] }
 
-      it "has tests" do
-        expect(entry.tests.map(&:content)).to match_array(["HP LaserJet 4100 Series", "HP LaserJet 2200"])
+      it 'has tests' do
+        expect(entry.tests.map(&:content)).to match_array(['HP LaserJet 4100 Series', 'HP LaserJet 2200'])
       end
     end
 
-    context "with external example content illegal path" do
+    context 'with external example content illegal path' do
       let(:xml_file) { File.expand_path File.join('spec', 'data', 'external_example_illegal_path_fingerprint.xml') }
       subject { Recog::DB.new(xml_file) }
 
-      it "raises an illegal file path error" do
+      it 'raises an illegal file path error' do
         expect { subject }.to raise_error(/an example specifies an illegal file path '.+'/)
       end
     end

data/spec/lib/recog/fingerprint/regexp_factory_spec.rb

@@ -1,12 +1,12 @@
+# frozen_string_literal: true
 
 require 'recog/fingerprint/regexp_factory'
 
 describe Recog::Fingerprint::RegexpFactory do
-
   describe 'FLAG_MAP' do
     subject { described_class::FLAG_MAP }
 
-    it "should have the right number of flags" do
+    it 'should have the right number of flags' do
       expect(subject.size).to be 5
     end
   end
@@ -15,56 +15,55 @@ describe Recog::Fingerprint::RegexpFactory do
     subject { described_class.build(pattern, options) }
 
     let(:pattern) { 'Apache/(\d+)' }
-    let(:options) { [ 'REG_ICASE' ] }
+    let(:options) { ['REG_ICASE'] }
 
     it { is_expected.to be_a(Regexp) }
     it { is_expected.to match('Apache/2') }
-
   end
 
   describe '.build_options' do
     subject { described_class.build_options(flags) }
 
-    let(:flags) { [ ] }
+    let(:flags) { [] }
     it { is_expected.to be_a(Integer) }
 
     context 'without any explicit flags' do
-      let(:flags) { [ ] }
-      specify "sets default flags" do
+      let(:flags) { [] }
+      specify 'sets default flags' do
         expect(subject).to be Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS
       end
     end
 
     context 'with REG_ICASE' do
-      let(:flags) { [ 'REG_ICASE' ] }
-      specify "sets IGNORECASE" do
-        expect(subject).to be (Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::IGNORECASE)
+      let(:flags) { ['REG_ICASE'] }
+      specify 'sets IGNORECASE' do
+        expect(subject).to be(Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::IGNORECASE)
       end
     end
 
     context 'with REG_DOT_NEWLINE' do
-      let(:flags) { [ 'REG_DOT_NEWLINE' ] }
-      specify "sets MULTILINE" do
-        expect(subject).to be (Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::MULTILINE)
+      let(:flags) { ['REG_DOT_NEWLINE'] }
+      specify 'sets MULTILINE' do
+        expect(subject).to be(Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::MULTILINE)
       end
     end
 
     context 'with REG_LINE_ANY_CRLF' do
-      let(:flags) { [ 'REG_LINE_ANY_CRLF' ] }
-      specify "sets MULTILINE" do
-        expect(subject).to be (Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::MULTILINE)
+      let(:flags) { ['REG_LINE_ANY_CRLF'] }
+      specify 'sets MULTILINE' do
+        expect(subject).to be(Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::MULTILINE)
       end
     end
 
     context 'with multiple flags' do
-      let(:flags) { [ 'REG_LINE_ANY_CRLF', 'REG_ICASE' ] }
-      specify "sets correct flags" do
-        expect(subject).to be (Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::MULTILINE | Regexp::IGNORECASE)
+      let(:flags) { %w[REG_LINE_ANY_CRLF REG_ICASE] }
+      specify 'sets correct flags' do
+        expect(subject).to be(Recog::Fingerprint::RegexpFactory::DEFAULT_FLAGS | Regexp::MULTILINE | Regexp::IGNORECASE)
       end
     end
 
     context 'with invalid flags' do
-      let(:flags) { %w(SYN ACK FIN) } # oh, wrong flags!
+      let(:flags) { %w[SYN ACK FIN] } # oh, wrong flags!
       specify 'raises and lists supported/unsupported flags' do
         expect { subject }.to raise_error(/SYN,ACK,FIN. Must be one of: .+/)
       end

data/spec/lib/recog/fingerprint_spec.rb

@@ -1,112 +1,114 @@
+# frozen_string_literal: true
+
 require 'nokogiri'
 require 'recog/fingerprint'
 
 describe Recog::Fingerprint do
-  context "whitespace" do
+  context 'whitespace' do
     let(:xml) do
       path = File.expand_path(File.join('spec', 'data', 'whitespaced_fingerprint.xml'))
       doc = Nokogiri::XML(IO.read(path))
-      doc.xpath("//fingerprint").first
+      doc.xpath('//fingerprint').first
     end
     subject { Recog::Fingerprint.new(xml) }
 
-    describe "#name" do
-      it "properly squashes whitespace" do
+    describe '#name' do
+      it 'properly squashes whitespace' do
         expect(subject.name).to eq('I love whitespace!')
       end
     end
   end
 
-  describe "#verification" do
+  describe '#verification' do
     let(:xml_file) { File.expand_path(File.join('spec', 'data', 'verification_fingerprints.xml')) }
     let(:doc) { Nokogiri::XML(IO.read(xml_file)) }
 
-    context "0 params" do
-      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[0]) }
+    context '0 params' do
+      let(:entry) { described_class.new(doc.xpath('//fingerprints/fingerprint')[0]) }
 
-      it "does not yield if a fingerprint has 0 parameters" do
+      it 'does not yield if a fingerprint has 0 parameters' do
         expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
       end
     end
 
-    context "0 capture groups" do
-      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[1]) }
+    context '0 capture groups' do
+      let(:entry) { described_class.new(doc.xpath('//fingerprints/fingerprint')[1]) }
 
-      it "does not yield if a fingerprint has parameters, but 0 are defined by a capture group " do
+      it 'does not yield if a fingerprint has parameters, but 0 are defined by a capture group ' do
         expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
       end
     end
 
-    context "0 examples" do
-      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[2]) }
+    context '0 examples' do
+      let(:entry) { described_class.new(doc.xpath('//fingerprints/fingerprint')[2]) }
 
-      it "does not yield if a fingerprint has 0 examples" do
+      it 'does not yield if a fingerprint has 0 examples' do
         expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
       end
     end
 
-    context "1 capture group, 1 example" do
-
-      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[3]) }
+    context '1 capture group, 1 example' do
+      let(:entry) { described_class.new(doc.xpath('//fingerprints/fingerprint')[3]) }
 
-      it "does not yield when one capture group parameter is tested for in one example" do
+      it 'does not yield when one capture group parameter is tested for in one example' do
         expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
       end
     end
 
-    context "2 capture groups, 1 example" do
-      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[4]) }
+    context '2 capture groups, 1 example' do
+      let(:entry) { described_class.new(doc.xpath('//fingerprints/fingerprint')[4]) }
 
-      it "does not yield when two capture group parameters are tested for in one example" do
+      it 'does not yield when two capture group parameters are tested for in one example' do
         expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
       end
     end
 
-    context "2 capture groups, 2 examples, 1 in each" do
-      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[5]) }
+    context '2 capture groups, 2 examples, 1 in each' do
+      let(:entry) { described_class.new(doc.xpath('//fingerprints/fingerprint')[5]) }
 
-      it "does not yield when two capture group parameters are tested for in two examples, one parameter in each" do
+      it 'does not yield when two capture group parameters are tested for in two examples, one parameter in each' do
         expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.not_to yield_control
       end
     end
 
-    context "1 missing capture group, 1 example" do
-
-      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[6]) }
+    context '1 missing capture group, 1 example' do
+      let(:entry) { described_class.new(doc.xpath('//fingerprints/fingerprint')[6]) }
 
-      it "identifies when a parameter defined by a capture group is not included in one example" do
+      it 'identifies when a parameter defined by a capture group is not included in one example' do
         expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.to yield_successive_args([:fail, String])
       end
     end
 
-    context "2 missing capture groups, 1 example" do
-      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[7]) }
+    context '2 missing capture groups, 1 example' do
+      let(:entry) { described_class.new(doc.xpath('//fingerprints/fingerprint')[7]) }
 
-      it "identifies when two parameters defined by a capture groups are not included in one example" do
-        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.to yield_successive_args([:fail, String], [:fail, String])
+      it 'identifies when two parameters defined by a capture groups are not included in one example' do
+        expect do |unused|
+          entry.verify_tests_have_capture_groups(&unused)
+        end.to yield_successive_args([:fail, String], [:fail, String])
       end
     end
 
-    context "1 missing capture group, 2 examples" do
+    context '1 missing capture group, 2 examples' do
+      let(:entry) { described_class.new(doc.xpath('//fingerprints/fingerprint')[8]) }
 
-      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[8]) }
-
-      it "identifies when a parameter defined by a capture group is not included in one example" do
+      it 'identifies when a parameter defined by a capture group is not included in one example' do
         expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.to yield_successive_args([:fail, String])
       end
     end
 
-    context "2 missing capture groups, 2 examples" do
-      let(:entry) { described_class.new(doc.xpath("//fingerprints/fingerprint")[9]) }
+    context '2 missing capture groups, 2 examples' do
+      let(:entry) { described_class.new(doc.xpath('//fingerprints/fingerprint')[9]) }
 
-      it "identifies when two parameters defined by a capture groups are not included in one example" do
-        expect { |unused| entry.verify_tests_have_capture_groups(&unused) }.to yield_successive_args([:fail, String], [:fail, String])
+      it 'identifies when two parameters defined by a capture groups are not included in one example' do
+        expect do |unused|
+          entry.verify_tests_have_capture_groups(&unused)
+        end.to yield_successive_args([:fail, String], [:fail, String])
       end
     end
-
   end
 
-  skip  "value interpolation" do
+  skip 'value interpolation' do
     # TODO
   end
 end

data/spec/lib/recog/formatter_spec.rb

@@ -1,66 +1,68 @@
+# frozen_string_literal: true
+
 require 'recog/formatter'
 
 describe Recog::Formatter do
   let(:output) { StringIO.new }
 
-  context "with no color" do
+  context 'with no color' do
     subject { Recog::Formatter.new(double(color: false), output) }
 
-    describe "#message" do
-      it "outputs the text" do
+    describe '#message' do
+      it 'outputs the text' do
         subject.status_message 'some text'
         expect(output.string).to eq("some text\n")
       end
     end
 
-    describe "#success_message" do
-      it "outputs the text" do
+    describe '#success_message' do
+      it 'outputs the text' do
         subject.success_message 'a success'
         expect(output.string).to eq("a success\n")
       end
     end
 
-    describe "#warning_message" do
-      it "outputs the text" do
+    describe '#warning_message' do
+      it 'outputs the text' do
         subject.warning_message 'a warning'
         expect(output.string).to eq("a warning\n")
       end
     end
 
-    describe "#failure_message" do
-      it "outputs the text" do
+    describe '#failure_message' do
+      it 'outputs the text' do
         subject.failure_message 'a failure'
         expect(output.string).to eq("a failure\n")
       end
     end
   end
 
-  context "with color" do
+  context 'with color' do
     subject { Recog::Formatter.new(double(color: true), output) }
 
-    describe "#message" do
-      it "outputs the text in white" do
+    describe '#message' do
+      it 'outputs the text in white' do
         subject.status_message 'some text'
         expect(output.string).to eq("\e[15msome text\e[0m\n")
       end
     end
 
-    describe "#success_message" do
-      it "outputs the text in green" do
+    describe '#success_message' do
+      it 'outputs the text in green' do
         subject.success_message 'a success'
         expect(output.string).to eq("\e[32ma success\e[0m\n")
       end
     end
 
-    describe "#warning_message" do
-      it "outputs the text in yellow" do
+    describe '#warning_message' do
+      it 'outputs the text in yellow' do
         subject.warning_message 'a warning'
         expect(output.string).to eq("\e[33ma warning\e[0m\n")
       end
     end
 
-    describe "#failure_message" do
-      it "outputs the text in red" do
+    describe '#failure_message' do
+      it 'outputs the text in red' do
         subject.failure_message 'a failure'
         expect(output.string).to eq("\e[31ma failure\e[0m\n")
       end

data/spec/lib/recog/match_reporter_spec.rb

@@ -1,103 +1,108 @@
+# frozen_string_literal: true
+
 require 'recog/match_reporter'
 
 describe Recog::MatchReporter do
-  let(:options) { double(detail: false, json_format: false, quiet: false, multi_match: false)  }
+  let(:options) { double(detail: false, json_format: false, quiet: false, multi_match: false) }
   let(:formatter) { double('formatter').as_null_object }
   subject { Recog::MatchReporter.new(options, formatter) }
 
   def run_report
     subject.report do
-        subject.increment_line_count
-        subject.match [{'data' => 'a match'}]
-        subject.failure 'a failure'
+      subject.increment_line_count
+      subject.match [{ 'data' => 'a match' }]
+      subject.failure 'a failure'
     end
   end
 
-  describe "#report" do
-    it "prints matches" do
+  describe '#report' do
+    it 'prints matches' do
       expect(formatter).to receive(:success_message).with('MATCH: {"data"=>"a match"}')
       run_report
     end
 
-    it "prints failures" do
+    it 'prints failures' do
       expect(formatter).to receive(:failure_message).with('FAIL: a failure')
       run_report
     end
 
-    context "with detail" do
-      subject { Recog::MatchReporter.new(double(detail: true, json_format: false, quiet: false, multi_match: false), formatter) }
+    context 'with detail' do
+      subject do
+        Recog::MatchReporter.new(double(detail: true, json_format: false, quiet: false, multi_match: false), formatter)
+      end
 
-      it "prints the lines processed" do
+      it 'prints the lines processed' do
         expect(formatter).to receive(:status_message).with("\nProcessed 1 lines")
         run_report
       end
 
-      it "prints summary" do
-        expect(formatter).to receive(:failure_message).with("SUMMARY: 1 matches and 1 failures")
+      it 'prints summary' do
+        expect(formatter).to receive(:failure_message).with('SUMMARY: 1 matches and 1 failures')
         run_report
       end
     end
 
-    context "with JSON" do
-      subject { Recog::MatchReporter.new(double(detail: false, json_format: true, quiet: false, multi_match: false), formatter) }
+    context 'with JSON' do
+      subject do
+        Recog::MatchReporter.new(double(detail: false, json_format: true, quiet: false, multi_match: false), formatter)
+      end
 
-      it "prints matches" do
+      it 'prints matches' do
         expect(formatter).to receive(:success_message).with('{"data":"a match","match":{}}')
         run_report
       end
 
-      it "prints failures" do
+      it 'prints failures' do
         expect(formatter).to receive(:failure_message).with('{"data":"a failure","match_failure":true,"match":null}')
         run_report
       end
     end
   end
 
-  describe "#print_summary" do
-    context "with all matches" do
+  describe '#print_summary' do
+    context 'with all matches' do
       before { subject.match ['match'] }
 
-      it "prints a successful summary" do
-        msg = "SUMMARY: 1 matches and 0 failures"
+      it 'prints a successful summary' do
+        msg = 'SUMMARY: 1 matches and 0 failures'
         expect(formatter).to receive(:success_message).with(msg)
         subject.print_summary
       end
     end
 
-    context "with failures" do
+    context 'with failures' do
       before { subject.failure 'fail' }
 
-      it "prints a failure summary" do
-        msg = "SUMMARY: 0 matches and 1 failures"
+      it 'prints a failure summary' do
+        msg = 'SUMMARY: 0 matches and 1 failures'
         expect(formatter).to receive(:failure_message).with(msg)
         subject.print_summary
       end
     end
   end
 
-  describe "#stop?" do
-    context "with a failure limit" do
-
+  describe '#stop?' do
+    context 'with a failure limit' do
       let(:options) { double(fail_fast: true, stop_after: 3, detail: false, json_format: false, multi_match: false) }
       before do
         subject.failure 'first'
         subject.failure 'second'
       end
 
-      it "returns true when the limit is reached " do
+      it 'returns true when the limit is reached ' do
         subject.failure 'third'
         expect(subject.stop?).to be true
       end
 
-      it "returns false when under the limit" do
+      it 'returns false when under the limit' do
         expect(subject.stop?).to be false
       end
     end
 
-    context "with no failure limit" do
+    context 'with no failure limit' do
       let(:options) { double(fail_fast: false, detail: false, json_format: false, multi_match: false) }
 
-      it "return false" do
+      it 'return false' do
         expect(subject.stop?).to be false
       end
     end