Shortcut for for statement

Gemfile

@@ -18,6 +18,6 @@ group :test do
   gem 'rubocop', '~> 0.53.0'
 
   platform :mri do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'reversable-range'
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: '9168659de45d6d576fce30c735f857e597fa26f6'
   end
 end

lib/liquid.rb

@@ -74,7 +74,6 @@ require 'liquid/condition'
 require 'liquid/utils'
 require 'liquid/tokenizer'
 require 'liquid/parse_context'
-require 'liquid/reversable_range'
 
 # Load all the tags of the standard library
 #

lib/liquid/context.rb

@@ -12,12 +12,12 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    attr_reader :scope, :errors, :registers, :environments, :resource_limits
     attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
 
     def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
       @environments     = [environments].flatten
-      @scopes           = [(outer_scope || {})]
+      @scope            = outer_scope || {}
       @registers        = registers
       @errors           = []
       @partial          = false
@@ -25,8 +25,6 @@ module Liquid
       @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
       squash_instance_assigns_with_environments
 
-      @this_stack_used = false
-
       self.exception_renderer = Template.default_exception_renderer
       if rethrow_errors
         self.exception_renderer = ->(e) { raise }
@@ -35,6 +33,8 @@ module Liquid
       @interrupts = []
       @filters = []
       @global_filter = nil
+
+      @stack_level = 0
     end
 
     def warnings
@@ -86,21 +86,9 @@ module Liquid
       strainer.invoke(method, *args).to_liquid
     end
 
-    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
-    def push(new_scope = {})
-      @scopes.unshift(new_scope)
-      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > Block::MAX_DEPTH
-    end
-
     # Merge a hash of variables in the current local scope
     def merge(new_scopes)
-      @scopes[0].merge!(new_scopes)
+      new_scopes.each { |k, v| self[k] = v }
-    end
-
-    # Pop from the stack. use <tt>Context#stack</tt> instead
-    def pop
-      raise ContextError if @scopes.size == 1
-      @scopes.shift
     end
 
     # Pushes a new local scope on the stack, pops it at the end of the block
@@ -111,32 +99,20 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope = nil)
+    def stack(*variable_names)
-      old_stack_used = @this_stack_used
+      @stack_level += 1
-      if new_scope
+      raise StackLevelError, "Nesting too deep".freeze if @stack_level > Block::MAX_DEPTH
-        push(new_scope)
+
-        @this_stack_used = true
+      begin
-      else
+        yield
-        @this_stack_used = false
+      ensure
+        @stack_level -= 1
       end
-
-      yield
-    ensure
-      pop if @this_stack_used
-      @this_stack_used = old_stack_used
-    end
-
-    def clear_instance_assigns
-      @scopes[0] = {}
     end
 
     # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
     def []=(key, value)
-      unless @this_stack_used
+      (@scope[key] ||= [nil]) << value
-        @this_stack_used = true
-        push({})
-      end
-      @scopes[0][key] = value
     end
 
     # Look up variable, either resolve directly after considering the name. We can directly handle
@@ -151,6 +127,29 @@ module Liquid
       evaluate(Expression.parse(expression))
     end
 
+    def unset(key)
+      if @scope[key].size <= 1
+        @scope.delete(key)
+      else
+        @scope[key].pop
+      end
+    end
+
+    def set_root(key, val)
+      @scope[key] ||= []
+      @scope[key][0] = val
+    end
+
+    def set_level(key, val, int)
+      @scope[key] ||= []
+      @scope[key][int] = val
+    end
+
+    def create_level(key)
+      (@scope[key] ||= [nil]) << nil
+      @scope[key].size - 1
+    end
+
     def key?(key)
       self[key] != nil
     end
@@ -161,27 +160,23 @@ module Liquid
 
     # Fetches an object starting at the local scope and then moving up the hierachy
     def find_variable(key, raise_on_not_found: true)
-      # This was changed from find() to find_index() because this is a very hot
+      trigger = false
-      # path and find_index() is optimized in MRI to reduce object allocation
+      value = @scope[key]
-      index = @scopes.find_index { |s| s.key?(key) }
+      scope = @scope unless value.nil?
-      scope = @scopes[index] if index
+      trigger = true unless value.nil?
-
-      variable = nil
 
       if scope.nil?
-        @environments.each do |e|
+        index = @environments.find_index do |e|
           variable = lookup_and_evaluate(e, key, raise_on_not_found: raise_on_not_found)
           # When lookup returned a value OR there is no value but the lookup also did not raise
           # then it is the value we are looking for.
-          if !variable.nil? || @strict_variables && raise_on_not_found
+          !variable.nil? || @strict_variables && raise_on_not_found
-            scope = e
-            break
-          end
         end
+
+        scope = @environments[index || -1]
       end
 
-      scope ||= @environments.last || @scopes.last
+      variable ||= lookup_and_evaluate(scope, key, trigger, raise_on_not_found: raise_on_not_found)
-      variable ||= lookup_and_evaluate(scope, key, raise_on_not_found: raise_on_not_found)
 
       variable = variable.to_liquid
       variable.context = self if variable.respond_to?(:context=)
@@ -189,12 +184,16 @@ module Liquid
       variable
     end
 
-    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
+    def lookup_and_evaluate(obj, key, trigger = false, raise_on_not_found: true)
       if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
         raise Liquid::UndefinedVariable, "undefined variable #{key}"
       end
 
-      value = obj[key]
+      value = if trigger == true
+        obj[key][-1]
+      else
+        obj[key]
+      end
 
       if value.is_a?(Proc) && obj.respond_to?(:[]=)
         obj[key] = (value.arity == 0) ? value.call : value.call(self)
@@ -213,10 +212,10 @@ module Liquid
     end
 
     def squash_instance_assigns_with_environments
-      @scopes.last.each_key do |k|
+      @scope.each_key do |k|
         @environments.each do |env|
           if env.key?(k)
-            scopes.last[k] = lookup_and_evaluate(env, k)
+            @scope[k] = [lookup_and_evaluate(env, k)]
             break
           end
         end

lib/liquid/range_lookup.rb

@@ -6,7 +6,7 @@ module Liquid
       if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
         new(start_obj, end_obj)
       else
-        ReversableRange.new(start_obj.to_i, end_obj.to_i)
+        start_obj.to_i..end_obj.to_i
       end
     end
 
@@ -18,7 +18,7 @@ module Liquid
     def evaluate(context)
       start_int = to_integer(context.evaluate(@start_obj))
       end_int = to_integer(context.evaluate(@end_obj))
-      ReversableRange.new(start_int, end_int)
+      start_int..end_int
     end
 
     private

lib/liquid/reversable_range.rb

@@ -1,77 +0,0 @@
-module Liquid
-  class ReversableRange
-    include Enumerable
-
-    def initialize(min, max)
-      @min = min
-      @max = max
-      @reversed = false
-    end
-
-    def each
-      if reversed
-        index = max
-        while index >= min
-          yield index
-          index -= 1
-        end
-      else
-        index = min
-        while index <= max
-          yield index
-          index += 1
-        end
-      end
-    end
-
-    def reverse!
-      @reversed = !reversed
-      self
-    end
-
-    def empty?
-      max < min
-    end
-
-    def size
-      difference = max - min
-      if difference > 0
-        difference + 1
-      else
-        0
-      end
-    end
-
-    def load_slice(from, to = nil)
-      to ||= max
-      slice_max = [max, to].min
-      slice_min = [min, from].max
-      range = ReversableRange.new(slice_min, slice_max)
-      range.reverse! if reversed
-      range
-    end
-
-    def ==(other)
-      other.is_a?(self.class) &&
-        other.min == min &&
-        other.max == max &&
-        other.reversed == reversed
-    end
-
-    def to_s
-      if reversed
-        "#{max}..#{min}"
-      else
-        "#{min}..#{max}"
-      end
-    end
-
-    def to_liquid
-      self
-    end
-
-    protected
-
-    attr_reader :min, :max, :reversed
-  end
-end

lib/liquid/tags/assign.rb

@@ -24,7 +24,7 @@ module Liquid
 
     def render(context)
       val = @from.render(context)
-      context.scopes.last[@to] = val
+      context.set_root(@to, val)
       context.resource_limits.assign_score += assign_score_of(val)
       ''.freeze
     end

lib/liquid/tags/capture.rb

@@ -24,7 +24,7 @@ module Liquid
 
     def render(context)
       output = super
-      context.scopes.last[@to] = output
+      context.set_root(@to, output)
       context.resource_limits.assign_score += output.bytesize
       ''.freeze
     end

lib/liquid/tags/case.rb

@@ -39,20 +39,19 @@ module Liquid
     end
 
     def render(context)
-      context.stack do
+      execute_else_block = true
-        execute_else_block = true
 
-        output = ''
+      output = ''
-        @blocks.each do |block|
+      @blocks.each do |block|
-          if block.else?
+        if block.else?
-            return block.attachment.render(context) if execute_else_block
+          return block.attachment.render(context) if execute_else_block
-          elsif block.evaluate(context)
+        elsif block.evaluate(context)
-            execute_else_block = false
+          execute_else_block = false
-            output << block.attachment.render(context)
+          output << block.attachment.render(context)
-          end
         end
-        output
       end
+
+      output
     end
 
     private

lib/liquid/tags/cycle.rb

@@ -34,15 +34,13 @@ module Liquid
     def render(context)
       context.registers[:cycle] ||= {}
 
-      context.stack do
+      key = context.evaluate(@name)
-        key = context.evaluate(@name)
+      iteration = context.registers[:cycle][key].to_i
-        iteration = context.registers[:cycle][key].to_i
+      result = context.evaluate(@variables[iteration])
-        result = context.evaluate(@variables[iteration])
+      iteration += 1
-        iteration += 1
+      iteration  = 0 if iteration >= @variables.size
-        iteration  = 0 if iteration >= @variables.size
+      context.registers[:cycle][key] = iteration
-        context.registers[:cycle][key] = iteration
+      result
-        result
-      end
     end
 
     private

lib/liquid/tags/for.rb

@@ -133,6 +133,7 @@ module Liquid
       end
 
       collection = context.evaluate(@collection_name)
+      collection = collection.to_a if collection.is_a?(Range)
 
       limit_value = context.evaluate(@limit)
       to = if limit_value.nil?
@@ -144,30 +145,30 @@ module Liquid
       segment = Utils.slice_collection(collection, from, to)
       segment.reverse! if @reversed
 
-      offsets[@name] = from + segment.size
+      offsets[@name] = from + segment.length
 
       segment
     end
 
     def render_segment(context, segment)
       for_stack = context.registers[:for_stack] ||= []
-      length = segment.size
+      length = segment.length
 
       result = ''
 
-      context.stack do
+      context.stack('forloop', @variable_name) do
         loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
 
         for_stack.push(loop_vars)
 
         begin
           context['forloop'.freeze] = loop_vars
+          level = context.create_level(@variable_name)
 
           segment.each do |item|
-            context[@variable_name] = item
+            context.set_level(@variable_name, item, level)
             result << @for_block.render(context)
             loop_vars.send(:increment!)
-
             # Handle any interrupts if they exist.
             if context.interrupt?
               interrupt = context.pop_interrupt
@@ -175,7 +176,10 @@ module Liquid
               next if interrupt.is_a? ContinueInterrupt
             end
           end
+          context.unset(@variable_name)
+          context.unset('forloop'.freeze)
         ensure
+
           for_stack.pop
         end
       end

lib/liquid/tags/if.rb

@@ -40,14 +40,12 @@ module Liquid
     end
 
     def render(context)
-      context.stack do
+      @blocks.each do |block|
-        @blocks.each do |block|
+        if block.evaluate(context)
-          if block.evaluate(context)
+          return block.attachment.render(context)
-            return block.attachment.render(context)
-          end
         end
-        ''.freeze
       end
+      ''.freeze
     end
 
     private

lib/liquid/tags/ifchanged.rb

@@ -1,15 +1,13 @@
 module Liquid
   class Ifchanged < Block
     def render(context)
-      context.stack do
+      output = super
-        output = super
 
-        if output != context.registers[:ifchanged]
+      if output != context.registers[:ifchanged]
-          context.registers[:ifchanged] = output
+        context.registers[:ifchanged] = output
-          output
+        output
-        else
+      else
-          ''.freeze
+        ''.freeze
-        end
       end
     end
   end

lib/liquid/tags/include.rb

@@ -60,7 +60,7 @@ module Liquid
       begin
         context.template_name = template_name
         context.partial = true
-        context.stack do
+        context.stack(context_variable_name, *@attributes.keys) do
           @attributes.each do |key, value|
             context[key] = context.evaluate(value)
           end

lib/liquid/tags/table_row.rb

@@ -31,7 +31,7 @@ module Liquid
       cols = context.evaluate(@attributes['cols'.freeze]).to_i
 
       result = "<tr class=\"row1\">\n"
-      context.stack do
+      context.stack('tablerowloop', @variable_name) do
         tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
         context['tablerowloop'.freeze] = tablerowloop
 

lib/liquid/tags/unless.rb

@@ -7,22 +7,20 @@ module Liquid
   #
   class Unless < If
     def render(context)
-      context.stack do
+      # First condition is interpreted backwards ( if not )
-        # First condition is interpreted backwards ( if not )
+      first_block = @blocks.first
-        first_block = @blocks.first
+      unless first_block.evaluate(context)
-        unless first_block.evaluate(context)
+        return first_block.attachment.render(context)
-          return first_block.attachment.render(context)
-        end
-
-        # After the first condition unless works just like if
-        @blocks[1..-1].each do |block|
-          if block.evaluate(context)
-            return block.attachment.render(context)
-          end
-        end
-
-        ''.freeze
       end
+
+      # After the first condition unless works just like if
+      @blocks[1..-1].each do |block|
+        if block.evaluate(context)
+          return block.attachment.render(context)
+        end
+      end
+
+      ''.freeze
     end
   end
 

lib/liquid/utils.rb

@@ -1,8 +1,6 @@
 module Liquid
   module Utils
     def self.slice_collection(collection, from, to)
-      return collection.load_slice(from, to) if collection.is_a?(ReversableRange)
-
       if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
         collection.load_slice(from, to)
       else

performance/shopify/comment_form.rb

@@ -15,7 +15,7 @@ class CommentForm < Liquid::Block
   def render(context)
     article = context[@variable_name]
 
-    context.stack do
+    context.stack('form') do
       context['form'] = {
         'posted_successfully?' => context.registers[:posted_successfully],
         'errors' => context['comment.errors'],

performance/shopify/paginate.rb

@@ -24,7 +24,7 @@ class Paginate < Liquid::Block
   def render(context)
     @context = context
 
-    context.stack do
+    context.stack('paginate') do
       current_page  = context['current_page'].to_i
 
       pagination = {

test/integration/drop_test.rb

@@ -1,14 +1,6 @@
 require 'test_helper'
 
 class ContextDrop < Liquid::Drop
-  def scopes
-    @context.scopes.size
-  end
-
-  def scopes_as_array
-    (1..@context.scopes.size).to_a
-  end
-
   def loop_pos
     @context['forloop.index']
   end
@@ -194,31 +186,6 @@ class DropsTest < Minitest::Test
     end
   end
 
-  def test_scope
-    assert_equal '1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new)
-    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-  end
-
-  def test_scope_though_proc
-    assert_equal '1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] })
-    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
-    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
-  end
-
-  def test_scope_with_assigns
-    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new)
-    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal 'test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new)
-    assert_equal 'test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new)
-  end
-
-  def test_scope_from_tags
-    assert_equal '1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
-  end
-
   def test_access_context_from_drop
     assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3])
   end

test/integration/standard_filter_test.rb

@@ -405,11 +405,11 @@ class StandardFiltersTest < Minitest::Test
   def test_map_over_drops_returning_procs
     drops = [
       {
-        "proc" => ->{ "foo" },
+        "proc" => ->{ "foo" }
       },
       {
-        "proc" => ->{ "bar" },
+        "proc" => ->{ "bar" }
-      },
+      }
     ]
     templ = '{{ drops | map: "proc" }}'
     assert_template_result "foobar", templ, "drops" => drops

test/integration/tags/for_tag_test.rb

@@ -36,10 +36,6 @@ HERE
     assert_template_result('321', '{%for item in array reversed %}{{item}}{%endfor%}', assigns)
   end
 
-  def test_for_range_reversed
-    assert_template_result('321', '{%for item in (1..3) reversed %}{{item}}{%endfor%}', {})
-  end
-
   def test_for_with_range
     assert_template_result(' 1  2  3 ', '{%for item in (1..3) %} {{item}} {%endfor%}')
 
@@ -372,6 +368,23 @@ HERE
     assert_template_result(expected, template, assigns)
   end
 
+  def test_overwriting_internal_variable
+    template = <<-HEREDOC
+    {% assign forloop = 'first' %}
+
+    {% for item in items %}
+      {{ forloop }}
+      {% assign forloop = 'second' %}
+      {{ forloop }}
+    {% endfor %}
+
+    {{ forloop }}
+    HEREDOC
+
+    result = Liquid::Template.parse(template).render('items' => '1')
+    assert_equal 'Liquid::ForloopDrop Liquid::ForloopDrop second', result.split.map(&:strip).join(' ')
+  end
+
   class LoaderDrop < Liquid::Drop
     attr_accessor :each_called, :load_slice_called
 

test/integration/tags/if_else_tag_test.rb

@@ -176,7 +176,7 @@ class IfElseTagTest < Minitest::Test
       [false, true, true] => true,
       [false, true, false] => false,
       [false, false, true] => false,
-      [false, false, false] => false,
+      [false, false, false] => false
     }
 
     tests.each do |vals, expected|

test/unit/context_unit_test.rb

@@ -102,21 +102,6 @@ class ContextUnitTest < Minitest::Test
     assert_nil @context['does_not_exist']
   end
 
-  def test_scoping
-    @context.push
-    @context.pop
-
-    assert_raises(Liquid::ContextError) do
-      @context.pop
-    end
-
-    assert_raises(Liquid::ContextError) do
-      @context.push
-      @context.pop
-      @context.pop
-    end
-  end
-
   def test_length_query
     @context['numbers'] = [1, 2, 3, 4]
 
@@ -170,18 +155,12 @@ class ContextUnitTest < Minitest::Test
 
   def test_add_item_in_outer_scope
     @context['test'] = 'test'
-    @context.push
-    assert_equal 'test', @context['test']
-    @context.pop
-    assert_equal 'test', @context['test']
-  end
 
-  def test_add_item_in_inner_scope
+    @context.stack('test') do
-    @context.push
+      assert_equal 'test', @context['test']
-    @context['test'] = 'test'
+    end
+
     assert_equal 'test', @context['test']
-    @context.pop
-    assert_nil @context['test']
   end
 
   def test_hierachical_data
@@ -349,9 +328,9 @@ class ContextUnitTest < Minitest::Test
 
   def test_ranges
     @context.merge("test" => '5')
-    assert_equal ReversableRange.new(1, 5), @context['(1..5)']
+    assert_equal (1..5), @context['(1..5)']
-    assert_equal ReversableRange.new(1, 5), @context['(1..test)']
+    assert_equal (1..5), @context['(1..test)']
-    assert_equal ReversableRange.new(5, 5), @context['(test..test)']
+    assert_equal (5..5), @context['(test..test)']
   end
 
   def test_cents_through_drop_nestedly

test/unit/reversable_range_unit_test.rb

@@ -1,116 +0,0 @@
-require 'test_helper'
-
-class ReversableRangeTest < Minitest::Test
-  include Liquid
-
-  def test_each_iterates_through_items_in_the_range
-    actual_items = []
-    ReversableRange.new(1, 10).each { |item| actual_items << item }
-
-    expected_items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-    assert_equal expected_items, actual_items
-  end
-
-  def test_implements_enumerable
-    actual_items = ReversableRange.new(1, 10).select(&:even?)
-
-    expected_items = [2, 4, 6, 8, 10]
-    assert_equal expected_items, actual_items
-  end
-
-  def test_is_not_empty_max_greater_than_min
-    range = ReversableRange.new(9, 10)
-
-    refute_predicate range, :empty?
-  end
-
-  def test_is_not_empty_max_equal_to_min
-    range = ReversableRange.new(10, 10)
-
-    refute_predicate range, :empty?
-  end
-
-  def test_is_empty_if_not_reversed_and_max_less_than_min
-    range = ReversableRange.new(10, 9)
-
-    assert_predicate range, :empty?
-  end
-
-  def test_ranges_with_the_same_max_and_min_have_one_element
-    actual_items = ReversableRange.new(1337, 1337).to_a
-    expected_items = [1337]
-    assert_equal expected_items, actual_items
-  end
-
-  def test_load_slice_returns_a_sub_range
-    actual_items = ReversableRange.new(1, 10).load_slice(5, 8).to_a
-
-    expected_items = [5, 6, 7, 8]
-    assert_equal expected_items, actual_items
-  end
-
-  def test_load_slice_returns_a_reversed_sub_range_if_reversed
-    range = ReversableRange.new(1, 10)
-    range.reverse!
-    actual_items = range.load_slice(5, 8).to_a
-
-    expected_items = [8, 7, 6, 5]
-    assert_equal expected_items, actual_items
-  end
-
-  def test_is_equal_to_other_if_also_a_reversable_range_and_has_same_properties
-    one = ReversableRange.new(1, 10)
-    one.reverse!
-
-    two = ReversableRange.new(1, 10)
-    two.reverse!
-
-    assert_equal one, two
-  end
-
-  def test_is_not_equal_to_a_non_reversable_range
-    range = ReversableRange.new(1, 10)
-    range.reverse!
-
-    refute_equal range, :something_else
-  end
-
-  def test_is_not_equal_if_ranges_have_different_mins
-    one = ReversableRange.new(1, 10)
-    two = ReversableRange.new(2, 10)
-
-    refute_equal one, two
-  end
-
-  def test_is_not_equal_if_ranges_have_different_maxes
-    one = ReversableRange.new(1, 10)
-    two = ReversableRange.new(1, 11)
-
-    refute_equal one, two
-  end
-
-  def test_is_not_equal_if_only_one_is_reversed
-    one = ReversableRange.new(1, 10)
-
-    two = ReversableRange.new(1, 10)
-    two.reverse!
-
-    refute_equal one, two
-  end
-
-  def test_to_s_mirrors_rubys_range_syntax
-    range = ReversableRange.new(1, 10)
-    assert_equal '1..10', range.to_s
-  end
-
-  def test_to_s_reverses_when_reversed
-    range = ReversableRange.new(1, 10)
-    range.reverse!
-    assert_equal '10..1', range.to_s
-  end
-
-  def test_size
-    range = ReversableRange.new(1, 10)
-    assert_equal 10, range.size
-  end
-end