BetterErrors / better_errors / 417

pending completion

Build # 417

Build Type

Pull #419

travis-ci

Committed by

web-flow

Commit Message

Rescue on undefined local variables in frame_binding

For example, I see errors on local variables: `m`, `args`, `block`, `r`, and `target` when inspecting an error on a class that inherits from SimpleDelegator.

Fix: Add a rescue on NameError to catch these.
Fixes issue: https://github.com/charliesome/better_errors/issues/351

Inspiration for this fix comes from @glebtv in https://github.com/glebtv/better_errors/commit/6d00365df

Pull Request Pull Request #419: Rescue on undefined local variables in frame_binding

Run Details

9 of 9 new or added lines in 1 file covered. (100.0%)

440 of 455 relevant lines covered (96.7%)

2177.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.57

/lib/better_errors/stack_frame.rb

require "set"

module BetterErrors
  # @private
  class StackFrame
    def self.from_exception(exception)
      RaisedException.new(exception).backtrace
    end

    attr_reader :filename, :line, :name, :frame_binding

    def initialize(filename, line, name, frame_binding = nil)
      @filename       = filename
      @line           = line
      @name           = name
      @frame_binding  = frame_binding

      set_pretty_method_name if frame_binding
    end

    def application?
      if root = BetterErrors.application_root
        filename.index(root) == 0 && filename.index("#{root}/vendor") != 0
      end
    end

    def application_path
      filename[(BetterErrors.application_root.length+1)..-1]
    end

    def gem?
      Gem.path.any? { |path| filename.index(path) == 0 }
    end

    def gem_path
      if path = Gem.path.detect { |p| filename.index(p) == 0 }
        gem_name_and_version, path = filename.sub("#{path}/gems/", "").split("/", 2)
        /(?<gem_name>.+)-(?<gem_version>[\w.]+)/ =~ gem_name_and_version
        "#{gem_name} (#{gem_version}) #{path}"
      end
    end

    def class_name
      @class_name
    end

    def method_name
      @method_name || @name
    end

    def context
      if gem?
        :gem
      elsif application?
        :application
      else
        :dunno
      end
    end

    def pretty_path
      case context
      when :application;  application_path
      when :gem;          gem_path
      else                filename
      end
    end

    def local_variables
      return {} unless frame_binding

      frame_binding.eval("local_variables").each_with_object({}) do |name, hash|
        # Ruby 2.2's local_variables will include the hidden #$! variable if
        # called from within a rescue context. This is not a valid variable name,
        # so the local_variable_get method complains. This should probably be
        # considered a bug in Ruby itself, but we need to work around it.
        next if name == :"\#$!"

        hash[name] = local_variable(name)
      end
    end

    def local_variable(name)
      get_local_variable(name) || eval_local_variable(name)
    rescue NameError => ex
      "#{ex.class}: #{ex.message}"
    end

    def instance_variables
      return {} unless frame_binding
      Hash[visible_instance_variables.map { |x|
        [x, frame_binding.eval(x.to_s)]
      }]
    end

    def visible_instance_variables
      frame_binding.eval("instance_variables") - BetterErrors.ignored_instance_variables
    end

    def to_s
      "#{pretty_path}:#{line}:in `#{name}'"
    end

  private
    def set_pretty_method_name
      name =~ /\A(block (\([^)]+\) )?in )?/
      recv = frame_binding.eval("self")

      return unless method_name = frame_binding.eval("::Kernel.__method__")

      if Module === recv
        @class_name = "#{$1}#{recv}"
        @method_name = ".#{method_name}"
      else
        @class_name = "#{$1}#{Kernel.instance_method(:class).bind(recv).call}"
        @method_name = "##{method_name}"
      end
    end

    def get_local_variable(name)
      if defined?(frame_binding.local_variable_get)
        frame_binding.local_variable_get(name)
      end
    end

    def eval_local_variable(name)
      frame_binding.eval(name.to_s)
    end
  end
end

1	require "set"	44✔
2
3	module BetterErrors	44✔
4	# @private
5	class StackFrame	44✔
6	def self.from_exception(exception)	44✔
7	RaisedException.new(exception).backtrace	264✔
8	end
9
10	attr_reader :filename, :line, :name, :frame_binding	44✔
11
12	def initialize(filename, line, name, frame_binding = nil)	44✔
13	@filename = filename	39,100✔
14	@line = line	39,100✔
15	@name = name	39,100✔
16	@frame_binding = frame_binding	39,100✔
17
18	set_pretty_method_name if frame_binding	39,100✔
19	end
20
21	def application?	44✔
22	if root = BetterErrors.application_root	45,671✔
23	filename.index(root) == 0 && filename.index("#{root}/vendor") != 0	132✔
24	end
25	end
26
27	def application_path	44✔
28	filename[(BetterErrors.application_root.length+1)..-1]	132✔
29	end
30
31	def gem?	44✔
32	Gem.path.any? { \|path\| filename.index(path) == 0 }	90,526✔
33	end
34
35	def gem_path	44✔
36	if path = Gem.path.detect { \|p\| filename.index(p) == 0 }	37,760✔
37	gem_name_and_version, path = filename.sub("#{path}/gems/", "").split("/", 2)	18,880✔
38	/(?<gem_name>.+)-(?<gem_version>[\w.]+)/ =~ gem_name_and_version	18,880✔
39	"#{gem_name} (#{gem_version}) #{path}"	18,880✔
40	end
41	end
42
43	def class_name	44✔
44	@class_name	7,883✔
45	end
46
47	def method_name	44✔
48	@method_name \|\| @name	7,839✔
49	end
50
51	def context	44✔
52	if gem?	45,175✔
53	:gem	40,888✔
54	elsif application?	4,287✔
55	:application	44✔
56	else
57	:dunno	4,243✔
58	end
59	end
60
61	def pretty_path	44✔
62	case context	21,790✔
63	when :application; application_path	44✔
64	when :gem; gem_path	18,748✔
65	else filename	2,998✔
66	end
67	end
68
69	def local_variables	44✔
70	return {} unless frame_binding	96✔
71
72	frame_binding.eval("local_variables").each_with_object({}) do \|name, hash\|	96✔
73	# Ruby 2.2's local_variables will include the hidden #$! variable if
74	# called from within a rescue context. This is not a valid variable name,
75	# so the local_variable_get method complains. This should probably be
76	# considered a bug in Ruby itself, but we need to work around it.
77	next if name == :"\#$!"	96✔
78
79	hash[name] = local_variable(name)	96✔
80	end
81	end
82
83	def local_variable(name)	44✔
84	get_local_variable(name) \|\| eval_local_variable(name)	96✔
85	rescue NameError => ex
86	"#{ex.class}: #{ex.message}"	×
87	end
88
89	def instance_variables	44✔
90	return {} unless frame_binding	96✔
91	Hash[visible_instance_variables.map { \|x\|	96✔
92	[x, frame_binding.eval(x.to_s)]	320✔
93	}]
94	end
95
96	def visible_instance_variables	44✔
97	frame_binding.eval("instance_variables") - BetterErrors.ignored_instance_variables	96✔
98	end
99
100	def to_s	44✔
101	"#{pretty_path}:#{line}:in `#{name}'"	13,475✔
102	end
103
104	private	44✔
105	def set_pretty_method_name	44✔
106	name =~ /\A(block (\([^)]+\) )?in )?/	18,572✔
107	recv = frame_binding.eval("self")	18,572✔
108
109	return unless method_name = frame_binding.eval("::Kernel.__method__")	18,572✔
110
111	if Module === recv	17,812✔
112	@class_name = "#{$1}#{recv}"	3,688✔
113	@method_name = ".#{method_name}"	3,688✔
114	else
115	@class_name = "#{$1}#{Kernel.instance_method(:class).bind(recv).call}"	14,124✔
116	@method_name = "##{method_name}"	14,124✔
117	end
118	end
119
120	def get_local_variable(name)	44✔
121	if defined?(frame_binding.local_variable_get)	96✔
122	frame_binding.local_variable_get(name)	78✔
123	end
124	end
125
126	def eval_local_variable(name)	44✔
127	frame_binding.eval(name.to_s)	18✔
128	end
129	end
130	end

BetterErrors / better_errors / 417

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous