Merge 9fffaf8 into 0f4508b

Author: tomeon

CHANGELOG.md

@@ -1,6 +1,8 @@
 ## Unreleased ([changes](https://github.com/infertux/bashcov/compare/v2.0.0...master))
 
-  * TBD
+  * [BUGFIX]  Correctly handle empty scripts by short-circuiting
+              `FieldStream#each` if the reader stream is at end-of-file before
+              the start-of-fields pattern is encountered (#41)
 
 ## v2.0.0, 2018-12-?? ([changes](https://github.com/infertux/bashcov/compare/v1.8.2...v2.0.0))
 

lib/bashcov/field_stream.rb

@@ -36,36 +36,48 @@ def each_field(delimiter)
     def each(delimiter, field_count, start_match)
       return enum_for(__method__, delimiter, field_count, start_match) unless block_given?
 
-      # The number of fields processed since passing the last start-of-fields
-      # match
-      seen_fields = 0
+      chunked = each_field(delimiter).chunk(&chunk_matches(start_match))
 
-      fields = each_field(delimiter)
+      yield_fields = lambda do |(_, chunk)|
+        chunk.each { |e| yield e }
+        (field_count - chunk.size).times { yield "" }
+      end
+
+      # Skip junk that might appear before the first start-of-fields match
+      begin
+        n, chunk = chunked.next
+        yield_fields.call([n, chunk]) unless n.zero?
+      rescue StopIteration
+        return
+      end
 
-      # Close over +field_count+ and +seen_fields+ to yield empty strings to
-      # the caller when we've already hit the next start-of-fields match
-      yield_remaining = -> { (field_count - seen_fields).times { yield "" } }
+      chunked.each(&yield_fields)
+    end
 
-      # Advance until the first start-of-fields match
-      loop { break if fields.next =~ start_match }
+  private
 
-      fields.each do |field|
-        # If the current field is the start-of-fields match...
-        if field.match?(start_match)
-          # Fill out any remaining (unparseable) fields with empty strings
-          yield_remaining.call
+    # @param [Regexp] start_match a +Regexp+ that, when matched against the
+    #   input stream, signifies the beginning of the next series of fields to
+    #   yield
+    # @return [Proc] a unary +Proc+ that returns +nil+ if the argument mathes
+    #   the +start_match+ +Regexp+, and otherwise returns the number of
+    #   start-of-fields signifiers so far encountered.
+    # @example
+    #   chunker = chunk_matches /<=>/
+    #   chunked = %w[foo fighters <=> bar none <=> baz luhrmann].chunk(&chunker)
+    #   chunked.to_a
+    #     #=> [[0, ["foo", "fighters"]], [1, ["bar", "none"]], [2, ["baz", "luhrmann"]]]
+    def chunk_matches(start_match)
+      i = 0
 
-          seen_fields = 0
-        elsif seen_fields < field_count
-          yield field
-          seen_fields += 1
+      lambda do |e|
+        if e.match?(start_match)
+          i += 1
+          nil
+        else
+          i
         end
       end
-
-      # One last filling-out of empty fields if we're at the end of the stream
-      yield_remaining.call
-
-      read.close unless read.closed?
     end
   end
 end

lib/bashcov/xtrace.rb

@@ -97,6 +97,8 @@ def read
         parse_hit!(*hit)
       end
 
+      @read.close unless @read.closed?
+
       @files
     end
 

spec/bashcov/field_stream_spec.rb

@@ -51,5 +51,25 @@
           yield_successive_args(*expected)
       end
     end
+
+    context "when the stream is empty or already fully consumed" do
+      let(:read) { StringIO.new }
+
+      it "short-circuits without yielding anything" do
+        expect { |e| stream.each(delimiter, field_count, start_match, &e) }.not_to yield_control
+      end
+    end
+
+    context "when stream contains fields prior to the first start-of-fields match" do
+      let(:before_start) { %w[some junk data] }
+      let(:after_start)  { %w[the good stuff] }
+      let(:field_count)  { 3 }
+      let(:input)        { (before_start + [start] + after_start).join(delimiter) }
+
+      it "discards them" do
+        expect { |e| stream.each(delimiter, field_count, start_match, &e) }.to \
+          yield_successive_args(*after_start)
+      end
+    end
   end
 end

spec/bashcov/runner_spec.rb

@@ -147,6 +147,18 @@
       end
     end
 
+    context "given an empty script" do
+      include_context "temporary script", "empty_script" do
+        let(:script_text) { "" }
+      end
+
+      it "returns empty coverage results" do
+        expect { tmprunner.run }.not_to raise_error
+        expect(tmprunner.result).to include(tmpscript.path)
+        expect(tmprunner.result[tmpscript.path]).to be_empty
+      end
+    end
+
     context "given a version of Bash prior to 4.1", if: Bashcov::BASH_VERSION < "4.1" do
       include_context "temporary script", "no_stderr" do
         let(:stderr_output) { "AIEEE!" }