RubyGems - ultra-safe-rb - Versions diffs - 0.0.1 - Mend

ultra-safe-rb 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (53) hide show

data/better_errors-2.10.1/lib/better_errors/templates/main.erb ADDED Viewed

@@ -0,0 +1,431 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title><%= exception_type %> at <%= request_path %></title>
+    <link rel="icon" href="data:;base64,=" />
+</head>
+<body class="better-errors-javascript-not-loaded">
+    <%# Stylesheets are placed in the <body> for Turbolinks compatibility. %>
+    <%== ErrorPageStyle.style_tag(csp_nonce) %>
+    <%# IE8 compatibility crap %>
+    <script nonce="<%= csp_nonce %>">
+    (function() {
+        var elements = ["section", "nav", "header", "footer", "audio"];
+        for (var i = 0; i < elements.length; i++) {
+            document.createElement(elements[i]);
+        }
+    })();
+    </script>
+    <%#
+      If Rails's Turbolinks is used, the Better Errors page is probably
+      rendered in the host app's layout. Let's empty out the styles of the
+      host app.
+    %>
+    <script nonce="<%= csp_nonce %>">
+      if (window.Turbolinks) {
+          for(var i=0; i < document.styleSheets.length; i++) {
+              if(document.styleSheets[i].href)
+                  document.styleSheets[i].disabled = true;
+          }
+          if (window.Turbolinks.controller) {
+              // Turbolinks > 5 (see https://github.com/turbolinks/turbolinks/issues/6)
+              document.addEventListener("turbolinks:load", function restoreCSS(e) {
+                  for(var i=0; i < document.styleSheets.length; i++) {
+                      document.styleSheets[i].disabled = false;
+                  }
+                  document.removeEventListener("turbolinks:load", restoreCSS, false);
+              });
+          } else {
+              document.addEventListener("page:restore", function restoreCSS(e) {
+                  for(var i=0; i < document.styleSheets.length; i++) {
+                      document.styleSheets[i].disabled = false;
+                  }
+                  document.removeEventListener("page:restore", restoreCSS, false);
+              });
+          }
+      }
+    </script>
+    <p class='no-inline-style-notice'>
+        <strong>
+            Better Errors can't apply inline style<span class='no-javascript-notice'> (or run Javascript)</span>,
+            possibly because you have a Content Security Policy along with Turbolinks.
+            But you can
+            <a href='/__better_errors' target="_blank">open the interactive console in a new tab/window</a>.
+        </strong>
+    </p>
+    <div class='top'>
+        <header class="exception">
+            <h2><strong><%= exception_type %></strong> <span>at <%= request_path %></span></h2>
+            <p><%= exception_message %></p>
+            <% unless active_support_actions.empty? %>
+                <div class='fix-actions'>
+                    <% active_support_actions.each do |action, _| %>
+                        <form class="button_to" method="post" action="<%= action_dispatch_action_endpoint %>">
+                            <input type="submit" value="<%= action %>">
+                            <input type="hidden" name="action" value="<%= action %>">
+                            <input type="hidden" name="error" value="<%= exception_type %>">
+                            <input type="hidden" name="location" value="<%= request_path %>">
+                        </form>
+                    <% end %>
+                </div>
+            <% end %>
+            <% if exception_hint %>
+              <h2>Hint: <%= exception_hint %></h2>
+            <% end %>
+        </header>
+    </div>
+    <section class="backtrace">
+        <nav class="sidebar">
+            <nav class="tabs">
+                <a href="#" id="application_frames">Application Frames</a>
+                <a href="#" id="all_frames">All Frames</a>
+            </nav>
+            <ul class="frames">
+                <% backtrace_frames.each_with_index do |frame, index| %>
+                    <li class="<%= frame.context %>" data-context="<%= frame.context %>" data-index="<%= index %>">
+                        <span class='stroke'></span>
+                        <i class="icon <%= frame.context %>"></i>
+                        <div class="info">
+                            <div class="name">
+                                <strong><%= frame.class_name %></strong><span class='method'><%= frame.method_name %></span>
+                            </div>
+                            <div class="location">
+                                <span class="filename"><%= frame.pretty_path %></span>, line <span class="line"><%= frame.line %></span>
+                            </div>
+                        </div>
+                    </li>
+                <% end %>
+            </ul>
+        </nav>
+        <div class="frameInfos">
+            <div class="frame_info current" data-frame-idx="0">
+                <p class='no-javascript-notice'>
+                    Better Errors can't run Javascript here<span class='no-inline-style-notice'> (or apply inline style)</span>,
+                    possibly because you have a Content Security Policy along with Turbolinks.
+                    But you can
+                    <a href='/__better_errors' target="_blank">open the interactive console in a new tab/window</a>.
+                </p>
+                <!-- this is enough information to show something in case JS doesn't get to load -->
+                <%== ErrorPage.render_template('variable_info', first_frame_variable_info) %>
+            </div>
+        </div>
+    </section>
+</body>
+<script nonce="<%= csp_nonce %>">
+(function() {
+    var OID = "<%= id %>";
+    var csrfToken = "<%= csrf_token %>";
+    var previousFrame = null;
+    var allFrames = document.querySelectorAll("ul.frames li");
+    var frameInfos = document.querySelector(".frameInfos");
+    document.querySelector('body').classList.remove("better-errors-javascript-not-loaded");
+    document.querySelector('body').classList.add("better-errors-javascript-loaded");
+    var noJSNotices = document.querySelectorAll('.no-javascript-notice');
+    for(var i = 0; i < noJSNotices.length; i++) {
+        noJSNotices[i].remove();
+    }
+    function apiCall(method, opts, cb) {
+        var req = new XMLHttpRequest();
+        req.open("POST", "//" + window.location.host + <%== uri_prefix.gsub("<", "&lt;").inspect %> + "/__better_errors/" + OID + "/" + method, true);
+        req.setRequestHeader("Content-Type", "application/json");
+        opts.csrfToken = csrfToken;
+        req.send(JSON.stringify(opts));
+        req.onreadystatechange = function() {
+            if(req.readyState == 4) {
+                var res = JSON.parse(req.responseText);
+                cb(res);
+            }
+        };
+    }
+    function escapeHTML(html) {
+        return html.replace(/&/, "&amp;").replace(/</g, "&lt;");
+    }
+    function hasConsoleBeenUsedPreviously() {
+      return !!document.cookie.split('; ').find(function(cookie) {
+          return cookie.startsWith('BetterErrors-has-used-console=');
+      });
+    }
+    var consoleHasBeenUsed = hasConsoleBeenUsedPreviously();
+    function consoleWasJustUsed() {
+        if (consoleHasBeenUsed) {
+            return;
+        }
+        hideConsoleHint();
+        consoleHasBeenUsed = true;
+        document.cookie = "BetterErrors-has-used-console=true;path=/;max-age=31536000;samesite"
+    }
+    function hideConsoleHint() {
+        document.querySelector('body').className += " console-has-been-used";
+    }
+    function REPL(index) {
+        this.index = index;
+        var previousCommands = JSON.parse(localStorage.getItem("better_errors_previous_commands"));
+        if(previousCommands === null) {
+          localStorage.setItem("better_errors_previous_commands", JSON.stringify([]));
+          previousCommands = [];
+        }
+        this.previousCommandOffset = previousCommands.length;
+    }
+    REPL.all = [];
+    REPL.prototype.install = function(containerElement) {
+        this.container = containerElement;
+        this.promptElement  = this.container.querySelector(".command-line .prompt");
+        this.inputElement   = this.container.querySelector("input");
+        this.outputElement  = this.container.querySelector("pre");
+        if (consoleHasBeenUsed) {
+            hideConsoleHint();
+        }
+        var self = this;
+        this.inputElement.onkeydown = function(ev) {
+            self.onKeyDown(ev);
+            consoleWasJustUsed();
+        };
+        this.setPrompt(">>");
+        REPL.all[this.index] = this;
+    };
+    REPL.prototype.focus = function() {
+        this.inputElement.focus();
+    };
+    REPL.prototype.setPrompt = function(prompt) {
+        this._prompt = prompt;
+        this.promptElement.innerHTML = escapeHTML(prompt);
+    };
+    REPL.prototype.getInput = function() {
+        return this.inputElement.value;
+    };
+    REPL.prototype.setInput = function(text) {
+        this.inputElement.value = text;
+        if(this.inputElement.setSelectionRange) {
+            // set cursor to end of input
+            this.inputElement.setSelectionRange(text.length, text.length);
+        }
+    };
+    REPL.prototype.writeRawOutput = function(output) {
+        this.outputElement.innerHTML += output;
+        this.outputElement.scrollTop = this.outputElement.scrollHeight;
+    };
+    REPL.prototype.writeOutput = function(output) {
+        this.writeRawOutput(escapeHTML(output));
+    };
+    REPL.prototype.sendInput = function(line) {
+        var self = this;
+        apiCall("eval", { "index": this.index, source: line }, function(response) {
+            if(response.error) {
+                self.writeOutput(response.error + "\n");
+            }
+            self.writeOutput(self._prompt + " ");
+            self.writeRawOutput("<span class='syntax-highlighted'>" + response.highlighted_input + "</span>\n");
+            self.writeOutput(response.result);
+            self.setPrompt(response.prompt);
+            self.setInput(response.prefilled_input);
+        });
+    };
+    REPL.prototype.onEnterKey = function() {
+        var text = this.getInput();
+        if(text != "" && text !== undefined) {
+            var previousCommands = JSON.parse(localStorage.getItem("better_errors_previous_commands"));
+            this.previousCommandOffset = previousCommands.push(text);
+            if(previousCommands.length > 100) {
+              previousCommands.splice(0, 1);
+              this.previousCommandOffset -= 1;
+            }
+            localStorage.setItem("better_errors_previous_commands", JSON.stringify(previousCommands));
+        }
+        this.setInput("");
+        this.sendInput(text);
+    };
+    REPL.prototype.onNavigateHistory = function(direction) {
+        this.previousCommandOffset += direction;
+        var previousCommands = JSON.parse(localStorage.getItem("better_errors_previous_commands"));
+        if(this.previousCommandOffset < 0) {
+            this.previousCommandOffset = -1;
+            this.setInput("");
+            return;
+        }
+        if(this.previousCommandOffset >= previousCommands.length) {
+            this.previousCommandOffset = previousCommands.length;
+            this.setInput("");
+            return;
+        }
+        this.setInput(previousCommands[this.previousCommandOffset]);
+    };
+    REPL.prototype.onKeyDown = function(ev) {
+        if(ev.keyCode == 13) {
+            this.onEnterKey();
+        } else if(ev.keyCode == 38 || (ev.ctrlKey && ev.keyCode == 80)) {
+            // the user pressed the up arrow or Ctrl-P
+            this.onNavigateHistory(-1);
+            ev.preventDefault();
+            return false;
+        } else if(ev.keyCode == 40 || (ev.ctrlKey && ev.keyCode == 78)) {
+            // the user pressed the down arrow or Ctrl-N
+            this.onNavigateHistory(1);
+            ev.preventDefault();
+            return false;
+        }
+    };
+    function switchTo(el) {
+        var currentFrameInfo = document.querySelectorAll('.frame_info.current');
+        for(var i = 0; i < currentFrameInfo.length; i++) {
+            currentFrameInfo[i].className = "frame_info";
+        }
+        el.className = "frame_info current";
+        var replInput = el.querySelector('.be-console input');
+        if (replInput) replInput.focus();
+    }
+    function selectFrameInfo(index) {
+        var el = document.querySelector(".frame_info[data-frame-idx='" + index + "']")
+        if (!el) {
+          el = document.createElement("div");
+          el.className = "frame_info";
+          el.setAttribute('data-frame-idx', index);
+          frameInfos.appendChild(el);
+        }
+        if(el) {
+            if (el.loaded) {
+                return switchTo(el);
+            }
+            apiCall("variables", { "index": index }, function(response) {
+                el.loaded = true;
+                if(response.error) {
+                    el.innerHTML = "<h2 class='error'>" + escapeHTML(response.error) + "</h2>";
+                    if(response.explanation) {
+                      el.innerHTML += "<p class='explanation'>" + escapeHTML(response.explanation) + "</p>";
+                    }
+                    el.innerHTML += "<p><a target='_new' href='https://github.com/BetterErrors/better_errors'>More about Better Errors</a></p>";
+                } else {
+                    el.innerHTML = response.html;
+                    var repl = el.querySelector(".be-repl .be-console");
+                    if(repl) {
+                        new REPL(index).install(repl);
+                    }
+                }
+                switchTo(el);
+            });
+        }
+    }
+    for(var i = 0; i < allFrames.length; i++) {
+        (function(i, el) {
+            var el = allFrames[i];
+            el.onclick = function() {
+                if(previousFrame) {
+                    previousFrame.className = "";
+                }
+                el.className = "selected";
+                previousFrame = el;
+                selectFrameInfo(el.attributes["data-index"].value);
+            };
+        })(i);
+    }
+    // Click the first application frame
+    (
+      document.querySelector(".frames li.application") ||
+      document.querySelector(".frames li")
+    ).onclick();
+    // This is the second query performed for frames; maybe the 'allFrames' list
+    // currently used and this list can be better used to avoid the repetition:
+    var applicationFramesCount = document.querySelectorAll(
+        "ul.frames li[data-context=application]"
+    ).length;
+    var applicationFramesButtonIsInstalled = false;
+    var applicationFramesButton = document.getElementById("application_frames");
+    var allFramesButton = document.getElementById("all_frames");
+    // The application frames button only needs to be bound if
+    // there are actually any application frames to look at.
+    var installApplicationFramesButton = function() {
+        applicationFramesButton.onclick = function() {
+            allFramesButton.className = "";
+            applicationFramesButton.className = "selected";
+            for(var i = 0; i < allFrames.length; i++) {
+                if(allFrames[i].attributes["data-context"].value == "application") {
+                    allFrames[i].style.display = "block";
+                } else {
+                    allFrames[i].style.display = "none";
+                }
+            }
+            return false;
+        };
+        applicationFramesButtonIsInstalled = true;
+    }
+    allFramesButton.onclick = function() {
+        if(applicationFramesButtonIsInstalled) {
+            applicationFramesButton.className = "";
+        }
+        allFramesButton.className = "selected";
+        for(var i = 0; i < allFrames.length; i++) {
+            allFrames[i].style.display = "block";
+        }
+        return false;
+    };
+    // If there are no application frames, select the 'All Frames'
+    // tab by default.
+    if(applicationFramesCount > 0) {
+        installApplicationFramesButton();
+        applicationFramesButton.onclick();
+    } else {
+        applicationFramesButton.className = "disabled";
+        applicationFramesButton.title = "No application frames available";
+        allFramesButton.onclick();
+    }
+})();
+</script>
+</html>
+<!-- generated by Better Errors in <%= Time.now.to_f - @start_time %> seconds -->

data/better_errors-2.10.1/lib/better_errors/templates/text.erb ADDED Viewed

@@ -0,0 +1,24 @@
+<%== text_heading("=", "%s at %s" % [exception_type, request_path]) %>
+<%== exception_message %>
+> To access an interactive console with this error, point your browser to: /__better_errors
+<% if backtrace_frames.any? -%>
+<%== text_heading("-", "%s, line %i" % [first_frame.pretty_path, first_frame.line]) %>
+``` ruby
+<%== ErrorPage.text_formatted_code_block(first_frame) %>```
+App backtrace
+-------------
+<%== application_frames.map { |s| " - #{s}" }.join("\n") %>
+Full backtrace
+--------------
+<%== backtrace_frames.map { |s| " - #{s}" }.join("\n") %>
+<% end %>

data/better_errors-2.10.1/lib/better_errors/templates/variable_info.erb ADDED Viewed

@@ -0,0 +1,82 @@
+<header class="trace_info clearfix">
+    <div class="title">
+        <h2 class="name"><%= frame.name %></h2>
+        <div class="location">
+          <span class="filename">
+            <a
+              href="<%= editor_url %>"
+              <%= ENV.key?('BETTER_ERRORS_INSIDE_FRAME') ? "target=_blank" : '' %>
+            ><%= frame.pretty_path %></a>
+          </span>
+        </div>
+    </div>
+    <div class="code_block clearfix">
+        <%== ErrorPage.html_formatted_code_block frame %>
+    </div>
+    <% if BetterErrors.binding_of_caller_available? && frame.frame_binding %>
+        <div class="be-repl">
+            <div class="be-console">
+                <pre></pre>
+                <div class="command-line"><span class='prompt'>&gt;&gt;</span> <input tabindex="1"/></div>
+            </div>
+        </div>
+    <% end %>
+</header>
+<% if BetterErrors.binding_of_caller_available? && frame.frame_binding %>
+    <div class="hint live-console-hint">
+        This is a live shell. Type in here.
+    </div>
+    <div class="variable_info"></div>
+<% end %>
+<% unless BetterErrors.binding_of_caller_available? %>
+    <div class="hint">
+        <strong>Tip:</strong> add <code>gem "binding_of_caller"</code> to your Gemfile to enable the REPL and local/instance variable inspection.
+    </div>
+<% end %>
+<%# TODO: move this outside of the frame info. It's not part of the frame. %>
+<div class="sub">
+    <h3>Request info</h3>
+    <div class='inset variables'>
+        <table class="var_table">
+            <% if rails_params %>
+                <tr><td class="name">Request parameters</td><td><pre><%== ErrorPage.inspect_value rails_params %></pre></td></tr>
+            <% end %>
+            <% if rack_session %>
+                <tr><td class="name">Rack session</td><td><pre><%== ErrorPage.inspect_value rack_session %></pre></td></tr>
+            <% end %>
+        </table>
+    </div>
+</div>
+<% if BetterErrors.binding_of_caller_available? && frame.frame_binding %>
+    <div class="sub">
+        <h3>Local Variables</h3>
+        <div class='inset variables'>
+            <table class="var_table">
+                <% frame.local_variables.each do |name, value| %>
+                    <tr><td class="name"><%= name %></td><td><pre><%== ErrorPage.inspect_value value %></pre></td></tr>
+                <% end %>
+            </table>
+        </div>
+    </div>
+    <div class="sub">
+        <h3>Instance Variables</h3>
+        <div class="inset variables">
+            <table class="var_table">
+                <% frame.instance_variables.each do |name, value| %>
+                    <tr><td class="name"><%= name %></td><td><pre><%== ErrorPage.inspect_value value %></pre></td></tr>
+                <% end %>
+            </table>
+        </div>
+    </div>
+<% end %>
+<% if start_time %>
+    <!-- variable_info took <%= Time.now.to_f - start_time %> seconds -->
+<% end %>

data/better_errors-2.10.1/lib/better_errors/version.rb ADDED Viewed

@@ -0,0 +1,4 @@
+module BetterErrors
+  # This is changed by CI before building a gem for release, but is not committed.
+  VERSION = "2.10.1"
+end

data/better_errors-2.10.1/lib/better_errors.rb ADDED Viewed

@@ -0,0 +1,144 @@
+require "pp"
+require "erubi"
+require "uri"
+require "better_errors/version"
+require "better_errors/code_formatter"
+require "better_errors/inspectable_value"
+require "better_errors/error_page"
+require "better_errors/middleware"
+require "better_errors/raised_exception"
+require "better_errors/repl"
+require "better_errors/stack_frame"
+require "better_errors/editor"
+module BetterErrors
+  class << self
+    # The path to the root of the application. Better Errors uses this property
+    # to determine if a file in a backtrace should be considered an application
+    # frame. If you are using Better Errors with Rails, you do not need to set
+    # this attribute manually.
+    #
+    # @return [String]
+    attr_accessor :application_root
+    # The logger to use when logging exception details and backtraces. If you
+    # are using Better Errors with Rails, you do not need to set this attribute
+    # manually. If this attribute is `nil`, nothing will be logged.
+    #
+    # @return [Logger, nil]
+    attr_accessor :logger
+    # @private
+    attr_accessor :binding_of_caller_available
+    # @private
+    alias_method :binding_of_caller_available?, :binding_of_caller_available
+    # The ignored instance variables.
+    # @return [Array]
+    attr_accessor :ignored_instance_variables
+    # The maximum variable payload size. If variable.inspect exceeds this,
+    # the variable won't be returned.
+    # @return int
+    attr_accessor :maximum_variable_inspect_size
+    # List of classes that are excluded from inspection.
+    # @return [Array]
+    attr_accessor :ignored_classes
+  end
+  @ignored_instance_variables = []
+  @maximum_variable_inspect_size = 100_000
+  @ignored_classes = ['ActionDispatch::Request', 'ActionDispatch::Response']
+  # Returns an object which responds to #url, which when called with
+  # a filename and line number argument,
+  # returns a URL to open the filename and line in the selected editor.
+  #
+  # Generates TextMate URLs by default.
+  #
+  #   BetterErrors.editor.url("/some/file", 123)
+  #     # => txmt://open?url=file:///some/file&line=123
+  #
+  # @return [Proc]
+  def self.editor
+    @editor ||= default_editor
+  end
+  # Configures how Better Errors generates open-in-editor URLs.
+  #
+  # @overload BetterErrors.editor=(sym)
+  #   Uses one of the preset editor configurations. Valid symbols are:
+  #
+  #   * `:textmate`, `:txmt`, `:tm`
+  #   * `:sublime`, `:subl`, `:st`
+  #   * `:macvim`
+  #   * `:atom`
+  #
+  #   @param [Symbol] sym
+  #
+  # @overload BetterErrors.editor=(str)
+  #   Uses `str` as the format string for generating open-in-editor URLs.
+  #
+  #   Use `%{file}` and `%{line}` as placeholders for the actual values.
+  #
+  #   @example
+  #     BetterErrors.editor = "my-editor://open?url=%{file}&line=%{line}"
+  #
+  #   @param [String] str
+  #
+  # @overload BetterErrors.editor=(proc)
+  #   Uses `proc` to generate open-in-editor URLs. The proc will be called
+  #   with `file` and `line` parameters when a URL needs to be generated.
+  #
+  #   Your proc should take care to escape `file` appropriately with
+  #   `URI.encode_www_form_component` (please note that `URI.escape` is **not**
+  #   a suitable substitute.)
+  #
+  #   @example
+  #     BetterErrors.editor = proc { |file, line|
+  #       "my-editor://open?url=#{URI.encode_www_form_component file}&line=#{line}"
+  #     }
+  #
+  #   @param [Proc] proc
+  #
+  def self.editor=(editor)
+    if editor.is_a? Symbol
+      @editor = Editor.editor_from_symbol(editor)
+      raise(ArgumentError, "Symbol #{editor} is not a symbol in the list of supported errors.") unless editor
+    elsif editor.is_a? String
+      @editor = Editor.for_formatting_string(editor)
+    elsif editor.respond_to? :call
+      @editor = Editor.for_proc(editor)
+    else
+      raise ArgumentError, "Expected editor to be a valid editor key, a format string or a callable."
+    end
+  end
+  # Enables experimental Pry support in the inline REPL
+  #
+  # If you encounter problems while using Pry, *please* file a bug report at
+  # https://github.com/BetterErrors/better_errors/issues
+  def self.use_pry!
+    REPL::PROVIDERS.unshift const: :Pry, impl: "better_errors/repl/pry"
+  end
+  # Automatically sniffs a default editor preset based on the EDITOR
+  # environment variable.
+  #
+  # @return [Symbol]
+  def self.default_editor
+    Editor.default_editor
+  end
+end
+begin
+  require "binding_of_caller"
+  require "better_errors/exception_extension"
+  BetterErrors.binding_of_caller_available = true
+rescue LoadError
+  BetterErrors.binding_of_caller_available = false
+end
+require "better_errors/rails" if defined? Rails::Railtie