test_erb.rb

class Mock
  attr_accessor :mock_original_name, :mock_call_stack

  def self.on(x)
    x.instance_eval do
      def method_missing(symbol, *args)
        puts "mocking #{self}.${symbol}(#{args.inspect})"
        @mock_call_stack ||= []
        @mock_call_stack << [symbol, args]
        self
      end
    end
  end

  def initialize(name)
    self.mock_original_name = name
    self.mock_call_stack    = []
  end

  def method_missing(symbol, *args)
    self.mock_call_stack << [symbol, args]
    self
  end

  def name
    self.to_s
  end

  def to_s
    # puts "  stringified call stack: #{self.mock_original_name}:#{self.mock_call_stack.inspect}"
    "#{self.mock_original_name}:#{self.mock_call_stack.inspect}"
  end

  def to_str
    self.to_s
  end
end

class ERB
  def mock_result(a_binding=new_toplevel)
    while true
      begin
        return self.result(a_binding)
      rescue NoMethodError => e
        if /undefined method `(?<undefined_nil_method>[^']+)' for nil:NilClass/ =~ e.message
          # puts "  defining singleton method: #{undefined_nil_method} on nil"
          a_binding.eval "nil.define_singleton_method('#{undefined_nil_method}', Proc.new{ Mock.new('nil') })"
        elsif /undefined method `(?<undefined_main_method>[^']+)' for main:Object/ =~ e.message
          # puts "  mocking method #{undefined_main_method}"
          a_binding.eval "def #{undefined_main_method}(*args) Mock.new('#{undefined_main_method}').call(args) end"
        else
          # puts "  unhandled NoMethodError"
          raise e
        end
      rescue NameError => e
        if /undefined local variable or method `(?<undefined_name>[^']+)' for main:Object/ =~ e.message
          # puts "  mocking #{undefined_name}"
          a_binding.local_variable_set undefined_name, Mock.new(undefined_name)
        else
          # puts "  unhandled NameError"
          raise e
        end
      end
    end
  end
end

Dir["#{Rails.root}/app/views/**/*.html.erb"].each do |file_name|
  # puts "beginning: #{file_name}"
  erb = ERB.new File.read(file_name)
  # puts "  loaded file"
  begin
    result = erb.mock_result
    errors = Open3.popen3("tidy") do |i,o,e,t|
      i.write result
      i.close
      errs = e.read
      t.value
      errs.lines.map do |line|
        line.chomp!
        if /^line (?<line_num>\d+) column (?<col_num>\d+) - (?<err_type>[^:]+): (?<err>.*)$/ =~ line
          [line_num.to_i, col_num.to_i, err_type, err]
        end
      end.compact
    end
    puts "in: #{file_name}"
    errors.each do |x|
      puts "  #{x.inspect}"
    end
  rescue TypeError => e
    if /gollum_monkey_patches/ === e.backtrace_locations.first.to_s
      puts "in: #{file_name}"
      puts "  I can't even"
    else
      raise e
    end
  rescue ArgumentError, SyntaxError, ActiveRecord::RecordNotFound, URI::InvalidURIError, LocalJumpError => e
    puts "in: #{file_name}"
    puts "  no idea what to do with a #{e.class}" #: #{e.message.lines.map{|x| "  " + x}.join}"
  end
  # puts "finished with: #{file_name}"
  # puts "----------------------------------------------------------------------------------------"
end