opal-connect-rspec 0.5.0

data/spec/rspec/mocks/filter/unsupported/receive_message_chain.rb

@@ -0,0 +1,4 @@
+rspec_filter 'receive_message_chain' do
+  # throw not supported on Opal 0.8
+  filter('receive_message_chain with only the expect syntax enabled works with and_throw').unless { at_least_opal_0_9? }
+end

data/spec/rspec/mocks/filter/unsupported/receive_messages.txt

@@ -0,0 +1,2 @@
+# line/number backtrace
+expect\(...\).to receive_messages\(:a => 1, :b => 2\) fails with the correct location

data/spec/rspec/mocks/filter/unsupported/should_syntax.txt

@@ -0,0 +1 @@
+Using the legacy should syntax #should_receive with an options hash reports the file and line submitted with :expected_from

data/spec/rspec/mocks/filter/unsupported/space.rb

@@ -0,0 +1,7 @@
+rspec_filter 'space' do
+  # no diff on Opal
+  filter 'RSpec::Mocks::Space can be diffed in a failure when it has references to an error generator via a proxy'
+
+  # mocking strings
+  filter 'RSpec::Mocks::Space#proxies_of(klass) returns proxies'
+end

data/spec/rspec/mocks/filter/unsupported/stub.rb

@@ -0,0 +1,7 @@
+rspec_filter 'stub' do
+  # no throw in Opal 0.8
+  unless at_least_opal_0_9?
+    filter('A method stub throws with argument when told to')
+    filter('A method stub throws when told to')
+  end
+end

data/spec/rspec/mocks/fixes/doubled_classes.rb

@@ -0,0 +1,76 @@
+# Copied from rspec-mocks/spec/support
+class LoadedClass
+  extend RSpec::Support::RubyFeatures
+
+  M = :m
+  N = :n
+  INSTANCE = LoadedClass.new
+
+  class << self
+
+    def respond_to?(method_name, include_all = false)
+      return true if method_name == :dynamic_class_method
+      super
+    end
+
+    def defined_class_method
+    end
+
+    def send
+      # fake out!
+    end
+
+  protected
+
+    def defined_protected_class_method
+    end
+
+  private
+
+    def defined_private_class_method
+    end
+
+  end
+
+  def defined_instance_method
+  end
+
+  def instance_method_with_two_args(a, b)
+  end
+
+  def instance_method_with_only_defaults(a=1, b=2)
+  end
+
+  # no eval on opal
+  #if required_kw_args_supported?
+    # Need to eval this since it is invalid syntax on earlier rubies.
+    #eval <<-RUBY
+      def kw_args_method(foo, optional_arg:'hello', required_arg:)
+      end
+
+      def mixed_args_method(foo, bar, optional_arg_1:1, optional_arg_2:2)
+      end
+    #RUBY
+  #end
+
+  def send(*)
+  end
+
+  def respond_to?(method_name, include_all = false)
+    return true if method_name == :dynamic_instance_method
+    super
+  end
+
+  class Nested; end
+
+protected
+
+  def defined_protected_method
+  end
+
+private
+
+  def defined_private_method
+    "wink wink ;)"
+  end
+end

data/spec/rspec/mocks/fixes/missing_constants.rb

@@ -0,0 +1,3 @@
+# None of this is supported in Opal
+module RSpec::Support::ShellOut
+end

data/spec/rspec/mocks/fixes/opal_itself.rb

@@ -0,0 +1,59 @@
+# https://github.com/opal/opal/issues/1110, fixed in Opal 0.9
+unless Opal::RSpec::Compatibility.class_within_class_new_works?
+  class ExpiredInstanceInterface
+    def foo;
+    end
+
+    def bar;
+    end
+
+    def bazz;
+    end
+  end
+
+  class ExpiredClassInterface
+    def self.foo;
+    end
+
+    def self.bar;
+    end
+
+    def self.bazz;
+    end
+  end
+
+  class ExampleClass
+    def hello
+      :hello_defined_on_class
+    end
+  end
+
+  module MethodMissing
+    remove_method :method_missing rescue nil
+
+    def method_missing(m, *a, &b)
+      if m == :captured_by_method_missing
+        "response generated by method missing"
+      else
+        super(m, *a, &b)
+      end
+    end
+  end
+
+  class Foo
+    def self.foo
+      bar
+    rescue StandardError
+    end
+  end
+
+  class OutOfGas < StandardError
+    attr_reader :amount, :units
+
+    def initialize(amount, units)
+      @amount = amount
+      @units = units
+    end
+  end
+end
+

data/spec/rspec/mocks/mocks_spec_loader.rb

@@ -0,0 +1,91 @@
+require_relative '../opal_rspec_spec_loader'
+
+module Opal
+  module RSpec
+    module MocksSpecLoader
+      extend Opal::RSpec::OpalRSpecSpecLoader
+
+      def self.expected_pending_count
+        10
+      end
+
+      def self.base_dir
+        'spec/rspec/mocks'
+      end
+
+      def self.files_with_line_continue
+        []
+      end
+
+      def self.default_path
+        'rspec-mocks/spec'
+      end
+
+      def self.spec_glob
+        %w{rspec-mocks/spec/**/*_spec.rb}
+      end
+
+      def self.stubbed_requires
+        [
+            'rubygems',
+            'rspec/support/spec/shell_out', # only does stuff Opal can't support anyways,
+            'spec', # we have our own version of this in spec_helper that's compatible
+            'simplecov', # hooks aren't available on Opal
+            'yaml', # not avail om opal yet
+            'psych',
+            'support/doubled_classes', # we have to create our own version of this due to eval in their code
+            'spec_helper' # we include our own spec helper that's opal compatible (spec_helper_opal)
+        ]
+      end
+
+      def self.symbol_files
+        [
+            /have_received_spec.rb/,
+            /stubbed_message_expectations_spec.rb/,
+            /stub_spec.rb/,
+            /receive_spec.rb/,
+            /hash_excluding_matcher_spec.rb/,
+            /hash_including_matcher_spec.rb/,
+            /\/double_spec.rb/,
+            /argument_matchers_spec.rb/
+        ]
+      end
+
+      def self.symbols_replace_regexes
+        [
+            /(expect.*description\)\.to eq)\((.*)\)/,
+            /(expect.*description\)\.to eq) (.*)/,
+            /(raise_error)\((%Q.*)\)/,
+            /(raise_error)\((\/received (?!:two).*\/.*)\)/,
+            /(raise_error\(RSpec::Mocks::MockExpectationError,) (.*\))/,
+            /(fail_\w+)\((\/expected: \\\({\(:.*)\)/,
+            # "expected: (hash_not_including(:a=>1))"
+            /(fail_\w+) ("expected: \(hash.*)/,
+            # fail_matching "expected: (duck_type(:abs, :div))"
+            /(fail_\w+) ("expected: \(duck_type.*)/
+        ]
+      end
+
+      def self.symbol_do_not_replace_regexes
+        # in these cases, the symbols do come in correctly in Opal
+        [
+            # fails when args are expected but none are received
+            'raise_error(RSpec::Mocks::MockExpectationError, %q|Double "test double" received unexpected message :foobar with (no args)|)',
+            # fails if unexpected method called
+            'raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received unexpected message :something with (\"a\", \"b\", \"c\")")'
+        ].map { |r| Regexp.new(Regexp.escape(r)) }
+      end
+
+      def self.sub_in_files
+        files = super
+        symbols_in_expectations files
+      end
+
+      def self.additional_load_paths
+        [
+            'rspec-mocks/spec' # a few spec support files live outside of rspec-mocks/spec/rspec and live in support
+        ]
+      end
+    end
+  end
+end

data/spec/rspec/mocks/require_specs.rb

@@ -0,0 +1,15 @@
+class ::RSpec::Core::Ordering::Random
+  # there are a lot of these in the RSpec specs that create noise
+  HIDE_RANDOM_WARNINGS = true
+end
+
+require 'support/before_all_shared_example_group'
+require 'rspec/support/spec/with_isolated_stderr'
+require 'rspec/support/spec/stderr_splitter'
+require 'rspec/support/spec/formatting_support'
+require 'opal/fixes/deprecation_helpers'
+require 'opal/fixes/rspec_helpers'
+require_relative 'spec_helper_opal'
+require_relative 'fixes/doubled_classes'
+require_relative 'fixes/missing_constants'
+require_relative 'fixes/opal_itself'

data/spec/rspec/mocks/spec_files_exclude.txt

@@ -0,0 +1,11 @@
+# Do not support marshalling in Opal
+**/marshal_extension_spec.rb
+
+# No private, public, etc.
+**/method_visibility_spec.rb
+
+# class_double depends on ClassVerifyingDouble inheriting from Module to support transferring nested constants, but that doesn't work on Opal
+**/class_double*_spec.rb
+
+# YAML/marshal serialization
+**/serialization_spec.rb

data/spec/rspec/mocks/spec_helper_opal.rb

@@ -0,0 +1,129 @@
+require 'rspec/support/spec'
+require 'rspec/support/ruby_features'
+
+require 'opal/progress_json_formatter' # verify case uses this
+# Only doing this because any_instance causes the runner itself to break
+CAUSES_SPECS_TO_CRASH = [
+    /.*allow_any_instance.*/,
+    /.*any_instance_of.*/
+]
+
+RSpec::Matchers.define :include_method do |expected|
+  match do |actual|
+    actual.map { |m| m.to_s }.include?(expected.to_s)
+  end
+end
+require 'support/matchers'
+
+module VerifyAndResetHelpers
+  def verify(object)
+    proxy = RSpec::Mocks.space.proxy_for(object)
+    proxy.verify
+  ensure
+    proxy.reset # so it doesn't fail the verify after the example completes
+  end
+
+  def reset(object)
+    RSpec::Mocks.space.proxy_for(object).reset
+  end
+
+  def verify_all
+    RSpec::Mocks.space.verify_all
+  ensure
+    reset_all
+  end
+
+  def reset_all
+    RSpec::Mocks.space.reset_all
+  end
+end
+
+module VerificationHelpers
+  def prevents(msg = //, &block)
+    expect(&block).to raise_error(RSpec::Mocks::MockExpectationError, msg)
+  end
+end
+
+require 'rspec/support/spec'
+
+RSpec.configure do |config|
+  config.expose_dsl_globally = false
+  config.mock_with :rspec
+  config.color = true
+  config.order = :random
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    $default_rspec_mocks_syntax = mocks.syntax
+    mocks.syntax = :expect
+  end
+
+  old_verbose = nil
+  config.before(:each, :silence_warnings) do
+    old_verbose = $VERBOSE
+    $VERBOSE = nil
+  end
+
+  config.after(:each, :silence_warnings) do
+    $VERBOSE = old_verbose
+  end
+
+  config.include VerifyAndResetHelpers
+  config.include VerificationHelpers
+  config.extend RSpec::Support::RubyFeatures
+  config.include RSpec::Support::RubyFeatures
+  config.filter_run_excluding full_description: Regexp.union(CAUSES_SPECS_TO_CRASH)
+  #config.full_description = 'when verify_partial_doubles configuration option is set.*'
+end
+
+RSpec.shared_context "with syntax" do |syntax|
+  orig_syntax = nil
+
+  before(:all) do
+    orig_syntax = RSpec::Mocks.configuration.syntax
+    RSpec::Mocks.configuration.syntax = syntax
+  end
+
+  after(:all) do
+    RSpec::Mocks.configuration.syntax = orig_syntax
+  end
+end
+
+
+RSpec.shared_context "with isolated configuration" do
+  orig_configuration = nil
+  before do
+    orig_configuration = RSpec::Mocks.configuration
+    RSpec::Mocks.instance_variable_set(:@configuration, RSpec::Mocks::Configuration.new)
+  end
+
+  after do
+    RSpec::Mocks.instance_variable_set(:@configuration, orig_configuration)
+  end
+end
+
+RSpec.shared_context "with monkey-patched marshal" do
+  before do
+    RSpec::Mocks.configuration.patch_marshal_to_support_partial_doubles = true
+  end
+
+  after do
+    RSpec::Mocks.configuration.patch_marshal_to_support_partial_doubles = false
+  end
+end
+
+RSpec.shared_context "with the default mocks syntax" do
+  orig_syntax = nil
+
+  before(:all) do
+    orig_syntax = RSpec::Mocks.configuration.syntax
+    RSpec::Mocks.configuration.reset_syntaxes_to_default
+  end
+
+  after(:all) do
+    RSpec::Mocks.configuration.syntax = orig_syntax
+  end
+end

data/spec/rspec/opal_rspec_spec_loader.rb

@@ -0,0 +1,359 @@
+require 'tmpdir'
+require_relative 'filter_processor'
+
+module Opal
+  module RSpec
+    module OpalRSpecSpecLoader
+      include Rake::DSL
+
+      def files_with_line_continue
+        []
+      end
+
+      def files_with_multiline_regex
+        []
+      end
+
+      def unstub_requires
+        []
+      end
+
+      def additional_load_paths
+        []
+      end
+
+      def post_requires
+        []
+      end
+
+      def get_ignored_spec_failures
+        text_based = FileList[File.join(base_dir, 'filter/**/*.txt')].map do |filename|
+          get_compact_text_expressions filename, wrap_in_regex=true
+        end.flatten
+        processor = FilterProcessor.new
+        FileList[File.join(base_dir, 'filter/**/*.rb')].exclude('**/sandbox/**/*').each do |filename|
+          processor.filename = filename
+          contents = File.read filename
+          processor.instance_eval contents
+        end
+        text_based + processor.all_filters
+      end
+
+      def stub_requires
+        stubbed_requires.each { |f| Opal::Processor.stub_file f }
+        unstub_requires.each do |f|
+          puts "Unstubbing #{f} per test request"
+          Opal::Processor.stubbed_files.delete f
+        end
+      end
+
+      def symbols_replace_regexes
+        [
+            /(fail_\w+)\((.*)\)/,
+            /(expect.*description\)\.to eq)\((.*)\)/,
+            /(expect.*description\)\.to eq) (.*)/
+        ]
+      end
+
+      def symbol_do_not_replace_regexes
+        []
+      end
+
+      def symbols_in_expectations(files)
+        matching = symbols_replace_regexes
+        # fail_with(/expected .* to respond to :some_method/)
+        replace_with_regex matching, 'fix symbols in message expectations', files, symbol_files do |match, temp_filename|
+          next match.to_s if symbol_do_not_replace_regexes.any? { |exp| exp.match match.to_s }
+          # Don't want to match #<Object:.*>
+          between_parens = match.captures[1]
+          symbol_matcher = /:([a-zA-Z]\w*)/
+          next match.to_s unless symbol_matcher.match(between_parens)
+          # Escape quotes if in a string
+          replace_pattern = if between_parens.start_with? '"'
+                              "\\\"\\1\\\""
+                            else
+                              "\"\\1\""
+                            end
+          fail_with_wo_symbols = between_parens.gsub(symbol_matcher, replace_pattern)
+          fail_type = match.captures[0]
+          new = "#{fail_type}(#{fail_with_wo_symbols})"
+          puts "#{temp_filename} - symbol fix -replacing #{match.to_s} with #{new} in new temp file"
+          new
+        end
+      end
+
+      def get_file_list
+        exclude_these_specs = get_compact_text_expressions File.join(base_dir, 'spec_files_exclude.txt'), wrap_in_regex=false
+        exclude_globs_only = exclude_these_specs.map { |f| f[:exclusion] }
+        files = FileList[
+            File.join(base_dir, 'require_specs.rb'), # need our code to go in first
+            *spec_glob
+        ].exclude(*exclude_globs_only)
+        missing_exclusions = exclude_these_specs.reject do |exclude|
+          FileList[exclude[:exclusion]].any?
+        end
+        if missing_exclusions.any?
+          raise "Expected to exclude #{missing_exclusions} as noted in spec_files_exclude.txt but we didn't find these files. Has RSpec been upgraded?"
+        end
+        files += post_requires.map { |r| File.join(base_dir, r) }
+        puts 'Running the following RSpec specs:'
+        files.each { |f| puts f }
+        files
+      end
+
+      def append_additional_load_paths(server)
+        baseline = [base_dir, 'spec/rspec/shared']
+        baseline += tmp_load_paths
+        (baseline + additional_load_paths).each { |p| server.append_path p }
+      end
+
+      def get_tmp_load_path_dir
+        dir = Dir.mktmpdir
+        at_exit do
+          FileUtils.remove_entry dir
+        end
+        # something was clearing this if it was added via Opal.append_path, so save it
+        tmp_load_paths << dir
+        dir
+      end
+
+      def tmp_load_paths
+        @tmp_load_paths ||= []
+      end
+
+      def replace_with_regex(regex, description, starting_file_set, files_to_replace)
+        fix_these_files = starting_file_set.select { |f| files_to_replace.any? { |r| r.match(f) } }
+        return starting_file_set unless fix_these_files.any?
+        dir = get_tmp_load_path_dir
+        missing = []
+        expressions = [*regex]
+        fixed_temp_files = fix_these_files.map do |path|
+          temp_filename = File.join dir, File.basename(path)
+          input = File.read path
+          matching = false
+          expressions.each do |r|
+            match = r.match input
+            if match
+              matching = true
+              input.gsub!(r) do |_|
+                yield Regexp.last_match, temp_filename
+              end
+            end
+          end
+          File.open temp_filename, 'w' do |output_file|
+            output_file.write input
+          end
+          missing << path unless matching
+          temp_filename
+        end
+        raise "Expected to #{description} in #{fix_these_files} but we didn't find any expressions in #{missing}. Check if RSpec has been upgraded" if missing.any?
+        files_we_left_alone = starting_file_set - fix_these_files
+        files_we_left_alone + fixed_temp_files
+      end
+
+      # https://github.com/opal/opal/issues/1125
+      def remove_multiline_regexes(files)
+        replace_with_regex /(%r%$.*%)$/m, 'fix multiline regex', files, files_with_multiline_regex do |match, temp_filename|
+          multi_line_regex = match
+                                 .captures[0]
+                                 .gsub("\n", '')
+          parsed = instance_eval multi_line_regex # can just have ruby do this for us
+          escaped = parsed
+                        .source
+                        .gsub('/', '\/')
+          replace = "/#{escaped}/m"
+          puts "Replacing multiline regex with #{replace} in new temp file #{temp_filename}"
+          replace
+        end
+      end
+
+      def sub_in_files
+        files = get_file_list
+        with_sub = sub_in_end_of_line files
+        remove_multiline_regexes with_sub
+      end
+
+      # https://github.com/opal/opal/issues/821
+      def sub_in_end_of_line(files)
+        bad_regex = /^(.*)\\$/
+        fix_these_files = files.select { |f| files_with_line_continue.any? { |regex| regex.match(f) } }
+        return files unless fix_these_files.any?
+        dir = get_tmp_load_path_dir
+        missing = []
+        fixed_temp_files = fix_these_files.map do |path|
+          temp_filename = File.join dir, File.basename(path)
+          found_blackslash = false
+          File.open path, 'r' do |input_file|
+            File.open temp_filename, 'w' do |output_file|
+              fixed_lines = input_file.inject do |line1, line2|
+                existing_lines = [*line1]
+                if (a_match = bad_regex.match existing_lines.last)
+                  found_blackslash = true
+                  line_num = existing_lines.length
+                  puts "Replacing trailing backlash, line #{line_num} in #{path} in new temp file #{temp_filename}"
+                  without_last_line = existing_lines[0..-2]
+                  without_backlash = a_match.captures[0]
+                  without_last_line << (without_backlash + ' ' + line2)
+                else
+                  existing_lines << line2
+                end
+              end
+              fixed_lines.each { |l| output_file << l }
+            end
+          end
+          missing << path unless found_blackslash
+          temp_filename
+        end
+        raise "Expected to fix blackslash continuation in #{fix_these_files} but we didn't find any backslashes in #{missing}. Check if RSpec has been upgraded (maybe those blackslashes are gone??)" if missing.any?
+        files_we_left_alone = files - fix_these_files
+        files_we_left_alone + fixed_temp_files
+      end
+
+      def execute_specs(name)
+        command_line = "SPEC_OPTS=\"--format Opal::RSpec::ProgressJsonFormatter\" rake #{name}"
+        puts "Running #{command_line}"
+        example_info = []
+        state = :progress
+        IO.popen(command_line).each do |line|
+          line.force_encoding 'UTF-8'
+          case state
+            when :progress
+              puts line
+            when :example_info
+              example_info << line
+          end
+          state = case line
+                    when /BEGIN JSON/
+                      :example_info
+                    else
+                      state
+                  end
+        end.close
+        {
+            example_info: example_info,
+            success: $?.success?
+        }
+      end
+
+      def parse_results(results)
+        JSON.parse results[:example_info].join("\n")
+      end
+
+      def rake_tasks_for(name)
+        Opal::RSpec::RakeTask.new(name) do |server, task|
+          # A lot of specs, can take longer on slower machines
+          task.timeout = 80000
+          stub_requires
+          task.files = sub_in_files
+          task.default_path = default_path
+          append_additional_load_paths server
+          server.debug = ENV['OPAL_DEBUG']
+        end
+
+        desc "Verifies that #{name} work correctly"
+        task "verify_#{name}" do
+          results = execute_specs name
+          parsed_results = parse_results results
+          summary = parsed_results['summary']
+          total = summary['example_count']
+          failed = summary['failure_count']
+          pending = summary['pending_count']
+          actual_failures = parsed_results['examples']
+                                .select { |ex| ex['status'] == 'failed' }
+          expected_failures = get_ignored_spec_failures
+          used_exclusions = []
+          remaining_failures = actual_failures.reject do |actual|
+            expected_failures.any? do |expected|
+              exclusion = expected[:exclusion]
+              actual_descr = actual['full_description']
+              matches = case exclusion
+                          when Regexp
+                            exclusion.match actual_descr
+                          when String
+                            exclusion == actual_descr
+                          else
+                            raise "Unknown filter expression type #{exclusion.class} in #{expected}!"
+                        end
+              used_exclusions << expected if matches
+              matches
+            end
+          end
+          each_header = '----------------------------------------------------'
+          index = 0
+          remaining_failures = remaining_failures.map do |example|
+            index += 1
+            [
+                each_header,
+                "Example #{index}: #{example['full_description']}",
+                each_header,
+                example['exception']['message']
+            ].join "\n"
+          end
+          reasons = []
+          unless remaining_failures.empty?
+            reasons << 'Unexpected failures'
+          end
+          reasons << "Expected #{expected_pending_count} pending but got #{pending}" unless pending == expected_pending_count
+          reasons << 'no specs found' unless total > 0
+          reasons << 'No failures, but Rake task did not succeed' if (failed == 0 && !results[:success])
+          unused_exclusions = expected_failures.uniq - used_exclusions.uniq
+          if unused_exclusions.any?
+            msg = "WARNING: The following #{unused_exclusions.length} exclusion rules did not match an actual failure. Time to update exclusions? Duplicate exclusions??\n" +
+                unused_exclusions.map { |e| "File: #{e[:filename]}\nLine #{e[:line_number]}\nFilter: #{e[:exclusion]}" }.join("\n---------------------\n")
+            reasons << msg
+          end
+          if reasons.empty?
+            puts 'Test successful!'
+            puts "#{total} total specs, #{failed} expected failures, #{pending} expected pending"
+          else
+            puts "Test FAILED for the following reasons:\n"
+            puts reasons.join "\n\n"
+            if remaining_failures.any?
+              puts
+              puts "Unexpected failures:\n\n#{remaining_failures.join("\n")}\n"
+            end
+            puts '-----------Summary-----------'
+            puts "Total passed count: #{total - failed - pending}"
+            puts "Pending count #{pending}"
+            puts "Total 'failure' count: #{actual_failures.length}"
+            puts "Unexpected failure count: #{remaining_failures.length}"
+            raise 'Test failed!'
+          end
+        end
+      end
+
+      def run_rack_server(rack)
+        Opal::Processor.source_map_enabled = false
+
+        files = sub_in_files
+        sprockets_env = Opal::RSpec::SprocketsEnvironment.new(spec_pattern=nil, spec_exclude_pattern=nil, spec_files=files)
+        rack.run Opal::Server.new(sprockets: sprockets_env) { |s|
+                   s.main = 'opal/rspec/sprockets_runner'
+                   stub_requires
+                   append_additional_load_paths s
+                   sprockets_env.add_spec_paths_to_sprockets
+                   s.debug = ENV['OPAL_DEBUG']
+                 }
+      end
+
+      private
+
+      def get_compact_text_expressions(filename, wrap_in_regex)
+        line_num = 0
+        File.read(filename).split("\n").map do |line|
+          line_num += 1
+          {
+              exclusion: line,
+              filename: filename,
+              line_number: line_num
+          }
+        end.reject do |line|
+          exclusion = line[:exclusion]
+          exclusion.empty? or exclusion.start_with? '#'
+        end.map do |filter|
+          wrap_in_regex ? filter.merge({exclusion: Regexp.new(filter[:exclusion])}) : filter
+        end
+      end
+    end
+  end
+end