tiny-pro-sys 0.0.1

data/web-console-4.3.0/lib/web_console/context.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module WebConsole
+  # A context lets you get object names related to the current session binding.
+  class Context
+    def initialize(binding)
+      @binding = binding
+    end
+
+    # Extracts entire objects which can be called by the current session unless
+    # the inputs is present.
+    #
+    # Otherwise, it extracts methods and constants of the object specified by
+    # the input.
+    def extract(input = nil)
+      input.present? ? local(input) : global
+    end
+
+    private
+
+      GLOBAL_OBJECTS = [
+        "instance_variables",
+        "local_variables",
+        "methods",
+        "class_variables",
+        "Object.constants",
+        "global_variables"
+      ]
+
+      def global
+        GLOBAL_OBJECTS.map { |cmd| eval(cmd) }
+      end
+
+      def local(input)
+        [
+          eval("#{input}.methods").map { |m| "#{input}.#{m}" },
+          eval("#{input}.constants").map { |c| "#{input}::#{c}" },
+        ]
+      end
+
+      def eval(cmd)
+        @binding.eval(cmd) rescue []
+      end
+  end
+end

data/web-console-4.3.0/lib/web_console/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module WebConsole
+  # The base class for every Web Console related error.
+  Error = Class.new(StandardError)
+
+  # Raised when there is an attempt to render a console more than once.
+  DoubleRenderError = Class.new(Error)
+end

data/web-console-4.3.0/lib/web_console/evaluator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module WebConsole
+  # Simple Ruby code evaluator.
+  #
+  # This class wraps a +Binding+ object and evaluates code inside of it. The
+  # difference of a regular +Binding+ eval is that +Evaluator+ will always
+  # return a string and will format exception output.
+  class Evaluator
+    # Cleanses exceptions raised inside #eval.
+    cattr_reader :cleaner, default: begin
+      cleaner = ActiveSupport::BacktraceCleaner.new
+      cleaner.add_silencer { |line| line.start_with?(File.expand_path("..", __FILE__)) }
+      cleaner
+    end
+
+    def initialize(binding = TOPLEVEL_BINDING)
+      @binding = binding
+    end
+
+    def eval(input)
+      # Binding#source_location is available since Ruby 2.6.
+      if @binding.respond_to? :source_location
+        "=> #{@binding.eval(input, *@binding.source_location).inspect}\n"
+      else
+        "=> #{@binding.eval(input).inspect}\n"
+      end
+    rescue Exception => exc
+      format_exception(exc)
+    end
+
+    private
+
+      def format_exception(exc)
+        backtrace = cleaner.clean(Array(exc.backtrace) - caller)
+
+        format = "#{exc.class.name}: #{exc}\n".dup
+        format << backtrace.map { |trace| "\tfrom #{trace}\n" }.join
+        format
+      end
+  end
+end

data/web-console-4.3.0/lib/web_console/exception_mapper.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module WebConsole
+  class ExceptionMapper
+    attr_reader :exc
+
+    def self.follow(exc)
+      mappers = [new(exc)]
+
+      while cause = (cause || exc).cause
+        mappers << new(cause)
+      end
+
+      mappers
+    end
+
+    def self.find_binding(mappers, exception_object_id)
+      mappers.detect do |exception_mapper|
+        exception_mapper.exc.object_id == exception_object_id.to_i
+      end || mappers.first
+    end
+
+    def initialize(exception)
+      @backtrace = exception.backtrace
+      @bindings = exception.bindings
+      @exc = exception
+    end
+
+    def first
+      guess_the_first_application_binding || @bindings.first
+    end
+
+    def [](index)
+      guess_binding_for_index(index) || @bindings[index]
+    end
+
+    private
+
+      def guess_binding_for_index(index)
+        file, line = @backtrace[index].to_s.split(":")
+        line = line.to_i
+
+        @bindings.find do |binding|
+          source_location = SourceLocation.new(binding)
+          source_location.path == file && source_location.lineno == line
+        end
+      end
+
+      def guess_the_first_application_binding
+        @bindings.find do |binding|
+          source_location = SourceLocation.new(binding)
+          source_location.path.to_s.start_with?(Rails.root.to_s)
+        end
+      end
+  end
+end

data/web-console-4.3.0/lib/web_console/extensions.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Kernel
+  module_function
+
+  # Instructs Web Console to render a console in the specified binding.
+  #
+  # If +binding+ isn't explicitly given it will default to the binding of the
+  # previous frame. E.g. the one that invoked +console+.
+  #
+  # Raises +DoubleRenderError+ if a more than one +console+ invocation per
+  # request is detected.
+  def console(binding = Bindex.current_bindings.second)
+    raise WebConsole::DoubleRenderError if Thread.current[:__web_console_binding]
+
+    Thread.current[:__web_console_binding] = binding
+
+    # Make sure nothing is rendered from the view helper. Otherwise
+    # you're gonna see unexpected #<Binding:0x007fee4302b078> in the
+    # templates.
+    nil
+  end
+end
+
+class Binding
+  # Instructs Web Console to render a console in the current binding, without
+  # the need to unroll the stack.
+  #
+  # Raises +DoubleRenderError+ if a more than one +console+ invocation per
+  # request is detected.
+  def console
+    Kernel.console(self)
+  end
+end

data/web-console-4.3.0/lib/web_console/injector.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module WebConsole
+  # Injects content into a Rack body.
+  class Injector
+    def initialize(body, headers)
+      @body = "".dup
+
+      body.each { |part| @body << part }
+      body.close if body.respond_to?(:close)
+
+      @headers = headers
+    end
+
+    def inject(content)
+      # Set content-length header to the size of the current body
+      # + the extra content. Otherwise the response will be truncated.
+      if @headers[Rack::CONTENT_LENGTH]
+        @headers[Rack::CONTENT_LENGTH] = (@body.bytesize + content.bytesize).to_s
+      end
+
+      [
+        if position = @body.rindex("</body>")
+          [ @body.insert(position, content) ]
+        else
+          [ @body << content ]
+        end,
+        @headers
+      ]
+    end
+  end
+end

data/web-console-4.3.0/lib/web_console/interceptor.rb

@@ -0,0 +1,17 @@
+module WebConsole
+  module Interceptor
+    def self.call(request, error)
+      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+
+      # Get the original exception if ExceptionWrapper decides to follow it.
+      Thread.current[:__web_console_exception] = error
+
+      # ActionView::Template::Error bypass ExceptionWrapper original
+      # exception following. The backtrace in the view is generated from
+      # reaching out to original_exception in the view.
+      if error.is_a?(ActionView::Template::Error)
+        Thread.current[:__web_console_exception] = error.cause
+      end
+    end
+  end
+end

data/web-console-4.3.0/lib/web_console/locales/en.yml

@@ -0,0 +1,15 @@
+en:
+  errors:
+    unavailable_session: |
+      Session %{id} is no longer available in memory.
+
+      If you happen to run on a multi-process server (like Unicorn or Puma) the process
+      this request hit doesn't store %{id} in memory. Consider turning the number of
+      processes/workers to one (1) or using a different server in development.
+
+    unacceptable_request: |
+      A supported version is expected in the Accept header.
+
+    connection_refused: |
+      Oops! Failed to connect to the Web Console middleware.
+      Please make sure a rails development server is running.

data/web-console-4.3.0/lib/web_console/middleware.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/strip"
+
+module WebConsole
+  class Middleware
+    TEMPLATES_PATH = File.expand_path("../templates", __FILE__)
+
+    cattr_accessor :mount_point, default: "/__web_console"
+    cattr_accessor :whiny_requests, default: true
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      app_exception = catch :app_exception do
+        request = create_regular_or_whiny_request(env)
+        return call_app(env) unless request.permitted?
+
+        if id = id_for_repl_session_update(request)
+          return update_repl_session(id, request)
+        elsif id = id_for_repl_session_stack_frame_change(request)
+          return change_stack_trace(id, request)
+        end
+
+
+        status, headers, body = call_app(env)
+
+        if (session = Session.from(Thread.current)) && acceptable_content_type?(headers)
+          headers["x-web-console-session-id"] = session.id
+          headers["x-web-console-mount-point"] = mount_point
+
+          template = Template.new(env, session)
+          body, headers = Injector.new(body, headers).inject(template.render("index"))
+        end
+
+        [ status, headers, body ]
+      end
+    rescue => e
+      WebConsole.logger.error("\n#{e.class}: #{e}\n\tfrom #{e.backtrace.join("\n\tfrom ")}")
+      raise e
+    ensure
+      # Clean up the fiber locals after the session creation. Object#console
+      # uses those to communicate the current binding or exception to the middleware.
+      Thread.current[:__web_console_exception] = nil
+      Thread.current[:__web_console_binding] = nil
+
+      raise app_exception if Exception === app_exception
+    end
+
+    private
+
+      def acceptable_content_type?(headers)
+        headers[Rack::CONTENT_TYPE].to_s.include?("html")
+      end
+
+      def json_response(opts = {})
+        status  = opts.fetch(:status, 200)
+        headers = { Rack::CONTENT_TYPE => "application/json; charset = utf-8" }
+        body    = yield.to_json
+
+        [ status, headers, [ body ] ]
+      end
+
+      def json_response_with_session(id, request, opts = {})
+        return respond_with_unavailable_session(id) unless session = Session.find(id)
+
+        json_response(opts) { yield session }
+      end
+
+      def create_regular_or_whiny_request(env)
+        request = Request.new(env)
+        whiny_requests ? WhinyRequest.new(request) : request
+      end
+
+      def repl_sessions_re
+        @_repl_sessions_re ||= %r{#{mount_point}/repl_sessions/(?<id>[^/]+)}
+      end
+
+      def update_re
+        @_update_re ||= %r{#{repl_sessions_re}\z}
+      end
+
+      def binding_change_re
+        @_binding_change_re ||= %r{#{repl_sessions_re}/trace\z}
+      end
+
+      def id_for_repl_session_update(request)
+        if request.xhr? && request.put?
+          update_re.match(request.path) { |m| m[:id] }
+        end
+      end
+
+      def id_for_repl_session_stack_frame_change(request)
+        if request.xhr? && request.post?
+          binding_change_re.match(request.path) { |m| m[:id] }
+        end
+      end
+
+      def update_repl_session(id, request)
+        json_response_with_session(id, request) do |session|
+          if input = request.params[:input]
+            { output: session.eval(input) }
+          elsif input = request.params[:context]
+            { context: session.context(input) }
+          end
+        end
+      end
+
+      def change_stack_trace(id, request)
+        json_response_with_session(id, request) do |session|
+          session.switch_binding_to(request.params[:frame_id], request.params[:exception_object_id])
+
+          { ok: true }
+        end
+      end
+
+      def respond_with_unavailable_session(id)
+        json_response(status: 404) do
+          { output: format(I18n.t("errors.unavailable_session"), id: id) }
+        end
+      end
+
+      def respond_with_unacceptable_request
+        json_response(status: 406) do
+          { output: I18n.t("errors.unacceptable_request") }
+        end
+      end
+
+      def call_app(env)
+        @app.call(env)
+      rescue => e
+        throw :app_exception, e
+      end
+  end
+end

data/web-console-4.3.0/lib/web_console/permissions.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+module WebConsole
+  class Permissions
+    # IPv4 and IPv6 localhost should be always allowed.
+    ALWAYS_PERMITTED_NETWORKS = %w( 127.0.0.0/8 ::1 ::ffff:127.0.0.0/104 )
+
+    def initialize(networks = nil)
+      @networks = normalize_networks(networks).map(&method(:coerce_network_to_ipaddr)).uniq
+    end
+
+    def include?(network)
+      @networks.any? { |permission| permission.include?(network.to_s) }
+    rescue IPAddr::InvalidAddressError
+      false
+    end
+
+    def to_s
+      @networks.map(&method(:human_readable_ipaddr)).join(", ")
+    end
+
+    private
+
+      def normalize_networks(networks)
+        Array(networks).concat(ALWAYS_PERMITTED_NETWORKS)
+      end
+
+      def coerce_network_to_ipaddr(network)
+        if network.is_a?(IPAddr)
+          network
+        else
+          IPAddr.new(network)
+        end
+      end
+
+      def human_readable_ipaddr(ipaddr)
+        ipaddr.to_range.to_s.split("..").uniq.join("/")
+      end
+  end
+end

data/web-console-4.3.0/lib/web_console/railtie.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module WebConsole
+  class Railtie < ::Rails::Railtie
+    config.web_console = ActiveSupport::OrderedOptions.new
+
+    initializer "web_console.initialize" do
+      require "bindex"
+      require "web_console/extensions"
+
+      ActionDispatch::DebugExceptions.register_interceptor(Interceptor)
+    end
+
+    initializer "web_console.development_only" do
+      unless (config.web_console.development_only == false) || Rails.env.development?
+        abort <<-END.strip_heredoc
+          Web Console is activated in the #{Rails.env} environment. This is
+          usually a mistake. To ensure it's only activated in development
+          mode, move it to the development group of your Gemfile:
+
+              gem 'web-console', group: :development
+
+          If you still want to run it in the #{Rails.env} environment (and know
+          what you are doing), put this in your Rails application
+          configuration:
+
+              config.web_console.development_only = false
+        END
+      end
+    end
+
+    initializer "web_console.insert_middleware" do |app|
+      app.middleware.insert_before ActionDispatch::DebugExceptions, Middleware
+    end
+
+    initializer "web_console.mount_point" do
+      if mount_point = config.web_console.mount_point
+        Middleware.mount_point = mount_point.chomp("/")
+      end
+
+      if root = Rails.application.config.relative_url_root
+        Middleware.mount_point = File.join(root, Middleware.mount_point)
+      end
+    end
+
+    initializer "web_console.template_paths" do
+      if template_paths = config.web_console.template_paths
+        Template.template_paths.unshift(*Array(template_paths))
+      end
+    end
+
+    initializer "web_console.deprecator" do |app|
+      app.deprecators[:web_console] = WebConsole.deprecator if app.respond_to?(:deprecators)
+    end
+
+    initializer "web_console.permissions" do
+      permissions = web_console_permissions
+      Request.permissions = Permissions.new(permissions)
+    end
+
+    def web_console_permissions
+      case
+      when config.web_console.permissions
+        config.web_console.permissions
+      when config.web_console.allowed_ips
+        config.web_console.allowed_ips
+      when config.web_console.whitelisted_ips
+        WebConsole.deprecator.warn(<<-MSG.squish)
+          The config.web_console.whitelisted_ips is deprecated and will be ignored in future release of web_console.
+          Please use config.web_console.allowed_ips instead.
+        MSG
+        config.web_console.whitelisted_ips
+      end
+    end
+
+    initializer "web_console.whiny_requests" do
+      if config.web_console.key?(:whiny_requests)
+        Middleware.whiny_requests = config.web_console.whiny_requests
+      end
+    end
+
+    initializer "i18n.load_path" do
+      config.i18n.load_path.concat(Dir[File.expand_path("../locales/*.yml", __FILE__)])
+    end
+  end
+end

data/web-console-4.3.0/lib/web_console/request.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module WebConsole
+  class Request < ActionDispatch::Request
+    cattr_accessor :permissions, default: Permissions.new
+
+    def permitted?
+      permissions.include?(strict_remote_ip)
+    end
+
+    def strict_remote_ip
+      GetSecureIp.new(self, permissions).to_s
+    rescue ActionDispatch::RemoteIp::IpSpoofAttackError
+      "[Spoofed]"
+    end
+
+    private
+
+      class GetSecureIp < ActionDispatch::RemoteIp::GetIp
+        def initialize(req, proxies)
+          # After rails/rails@07b2ff0 ActionDispatch::RemoteIp::GetIp initializes
+          # with a ActionDispatch::Request object instead of plain Rack
+          # environment hash. Keep both @req and @env here, so we don't if/else
+          # on Rails versions.
+          @req      = req
+          @env      = req.env
+          @check_ip = true
+          @proxies  = proxies
+        end
+
+        # Used by rails <= 8.1
+        def filter_proxies(ips)
+          ips.reject do |ip|
+            @proxies.include?(ip)
+          end
+        end
+
+        # Used by rails > 8.1.
+        def first_non_proxy(ips)
+          ips.find do |ip|
+            !@proxies.include?(ip)
+          end
+        end
+      end
+  end
+end

data/web-console-4.3.0/lib/web_console/session.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module WebConsole
+  # A session lets you persist an +Evaluator+ instance in memory associated
+  # with multiple bindings.
+  #
+  # Each newly created session is persisted into memory and you can find it
+  # later by its +id+.
+  #
+  # A session may be associated with multiple bindings. This is used by the
+  # error pages only, as currently, this is the only client that needs to do
+  # that.
+  class Session
+    cattr_reader :inmemory_storage, default: {}
+
+    class << self
+      # Finds a persisted session in memory by its id.
+      #
+      # Returns a persisted session if found in memory.
+      # Raises NotFound error unless found in memory.
+      def find(id)
+        inmemory_storage[id]
+      end
+
+      # Create a Session from an binding or exception in a storage.
+      #
+      # The storage is expected to respond to #[]. The binding is expected in
+      # :__web_console_binding and the exception in :__web_console_exception.
+      #
+      # Can return nil, if no binding or exception have been preserved in the
+      # storage.
+      def from(storage)
+        if exc = storage[:__web_console_exception]
+          new(ExceptionMapper.follow(exc))
+        elsif binding = storage[:__web_console_binding]
+          new([[binding]])
+        end
+      end
+    end
+
+    # An unique identifier for every REPL.
+    attr_reader :id
+
+    def initialize(exception_mappers)
+      @id = SecureRandom.hex(16)
+
+      @exception_mappers = exception_mappers
+      @evaluator         = Evaluator.new(@current_binding = exception_mappers.first.first)
+
+      store_into_memory
+    end
+
+    # Evaluate +input+ on the current Evaluator associated binding.
+    #
+    # Returns a string of the Evaluator output.
+    def eval(input)
+      @evaluator.eval(input)
+    end
+
+    # Switches the current binding to the one at specified +index+.
+    #
+    # Returns nothing.
+    def switch_binding_to(index, exception_object_id)
+      bindings = ExceptionMapper.find_binding(@exception_mappers, exception_object_id)
+
+      @evaluator = Evaluator.new(@current_binding = bindings[index.to_i])
+    end
+
+    # Returns context of the current binding
+    def context(objpath)
+      Context.new(@current_binding).extract(objpath)
+    end
+
+    private
+
+      def store_into_memory
+        inmemory_storage[id] = self
+      end
+  end
+end

data/web-console-4.3.0/lib/web_console/source_location.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module WebConsole
+  class SourceLocation
+    def initialize(binding)
+      @binding = binding
+    end
+
+    def path() @binding.source_location.first end
+    def lineno() @binding.source_location.last end
+  end
+end