Refactor unparser specs to accommodate assertions against non-default parser/builder options

gladtocode · gladtocode · commit b7f745a7ec79 · 2018-07-18T11:00:37.000-06:00
This commit refactors the specs in two ways:

1. Accommodate non-default parser/builder options such
  as `emit_file_line_as_literals`

  For example, specifying parser builder options:

    with_builder_options({ emit_file_line_as_literals: true }) do
      assert_generates '__FILE__', '"(string)"'
      assert_generates '__LINE__', '1'
    end

    with_builder_options({ emit_file_line_as_literals: false }) do
      assert_source '__FILE__'
      assert_source '__LINE__'
    end

2. Simpler accommodation for future Ruby changes so assertions can easily
  be targeted at versions of Ruby after a certain version or prior
  to a certain version. For example, when 2.4 is added, we can block
  certain behavior to end at 2.3, and other behavior to start at 2.4.

  For example, specifying Ruby versions for particular assertions.

    with_ruby_versions(beginning_at: '2.3') do
      assert_terminated 'a&amp;.b'
      assert_terminated 'a&amp;.b(c)'
    end

    with_ruby_versions(only: '2.3') do
      # ... asertions
    end

    with_ruby_versions(ending_at: '2.3') do
      # ... assertions
    end
diff --git a/spec/support/parser_class_generator.rb b/spec/support/parser_class_generator.rb
@@ -0,0 +1,21 @@
+module ParserClassGenerator
+  def self.generate_with_options(base_parser_class, builder_options)
+    # This builds a dynamic subclass of the base_parser_class (e.g. Parser::Ruby23)
+    # and overrides the default_parser method to return a parser whose builder
+    # has various options set.
+    #
+    # Currently the only builder option is :emit_file_line_as_literals
+
+    Class.new(base_parser_class) do
+      define_singleton_method(:default_parser) do |*args|
+        super(*args).tap do |parser|
+          parser.builder.emit_file_line_as_literals = builder_options[:emit_file_line_as_literals]
+        end
+      end
+
+      define_singleton_method(:inspect) do
+        "#{base_parser_class.inspect} with builder options: #{builder_options.inspect}"
+      end
+    end
+  end
+end
diff --git a/spec/unit/unparser_spec.rb b/spec/unit/unparser_spec.rb
@@ -1,26 +1,76 @@
 require 'spec_helper'
 require 'parser/all'
+require 'support/parser_class_generator'
 
 describe Unparser, mutant_expression: 'Unparser::Emitter*' do
   describe '.unparse' do
 
-    PARSERS = IceNine.deep_freeze(
+    RUBY_VERSION_PARSERS = IceNine.deep_freeze(
       '2.1' => Parser::Ruby21,
       '2.2' => Parser::Ruby22,
       '2.3' => Parser::Ruby23
     )
 
-    RUBIES = PARSERS.keys.freeze
+    RUBY_VERSIONS = RUBY_VERSION_PARSERS.keys.freeze
 
-    def self.parser_for_ruby_version(version)
-      PARSERS.fetch(version) do
-        raise "Unrecognized Ruby version #{version}"
+    def self.builder_options
+      @builder_options ||= {}
+    end
+
+    def self.builder_options=(options)
+      @builder_options = options
+    end
+
+    def self.ruby_versions
+      @ruby_versions ||= RUBY_VERSIONS
+    end
+
+    def self.ruby_versions=(versions)
+      @ruby_versions = versions
+    end
+
+    def self.with_ruby_versions(beginning_at: nil, ending_at: nil, only: nil)
+      original_ruby_versions = ruby_versions
+      if only
+        self.ruby_versions = only & ruby_versions # intersection
+      else
+        if ending_at
+          idx = ruby_versions.index(ending_at) || fail('Invalid Ruby specified')
+          self.ruby_versions = ruby_versions[0..idx]
+        end
+        if beginning_at
+          idx = ruby_versions.index(beginning_at) || fail('Invalid Ruby specified')
+          self.ruby_versions = ruby_versions[idx..-1]
+        end
       end
+
+      yield
+
+      self.ruby_versions = original_ruby_versions
     end
 
-    def self.with_versions(versions)
-      versions.each do |version|
-        yield parser_for_ruby_version(version)
+    def self.current_parsers
+      ruby_versions.map do |ruby_version|
+        if builder_options != {}
+          ParserClassGenerator.generate_with_options(parser_for_ruby_version(ruby_version), builder_options)
+        else
+          parser_for_ruby_version(ruby_version)
+        end
+      end
+    end
+
+    def self.with_builder_options(options)
+      original_options = builder_options
+      self.builder_options = builder_options.merge(options)
+
+      yield
+
+      self.builder_options = original_options
+    end
+
+    def self.parser_for_ruby_version(version)
+      RUBY_VERSION_PARSERS.fetch(version) do
+        raise "Unrecognized Ruby version #{version}"
       end
     end
 
@@ -50,14 +100,14 @@ def self.assert_unterminated(expression)
       assert_source("(#{expression}).foo")
     end
 
-    def self.assert_terminated(expression, rubies = RUBIES)
-      assert_source(expression, rubies)
-      assert_source("foo(#{expression})", rubies)
-      assert_source("#{expression}.foo", rubies)
+    def self.assert_terminated(expression)
+      assert_source(expression)
+      assert_source("foo(#{expression})")
+      assert_source("#{expression}.foo")
     end
 
-    def self.assert_generates(ast_or_string, expected, versions = RUBIES)
-      with_versions(versions) do |parser|
+    def self.assert_generates(ast_or_string, expected)
+      current_parsers.each do |parser|
         it "should generate #{ast_or_string} as #{expected} under #{parser.inspect}" do
           if ast_or_string.is_a?(String)
             expected = strip(expected)
@@ -69,16 +119,16 @@ def self.assert_generates(ast_or_string, expected, versions = RUBIES)
       end
     end
 
-    def self.assert_round_trip(input, versions = RUBIES)
-      with_versions(versions) do |parser|
+    def self.assert_round_trip(input)
+      current_parsers.each do |parser|
         it "should round trip #{input} under #{parser.inspect}" do
           assert_round_trip(input, parser)
         end
       end
     end
 
-    def self.assert_source(input, versions = RUBIES)
-      assert_round_trip(strip(input), versions)
+    def self.assert_source(input)
+      assert_round_trip(strip(input))
     end
 
     context 'kwargs' do
@@ -408,8 +458,10 @@ def foo
     end
 
     context 'conditional send (csend)' do
-      assert_terminated 'a&.b',    %w(2.3)
-      assert_terminated 'a&.b(c)', %w(2.3)
+      with_ruby_versions(beginning_at: '2.3') do
+        assert_terminated 'a&.b'
+        assert_terminated 'a&.b(c)'
+      end
     end
 
     context 'send' do
