sidekiq 5.2.7 → 8.0.5

data/lib/sidekiq/web/action.rb

@@ -1,89 +1,154 @@
 # frozen_string_literal: true
 
+require "erb"
+
 module Sidekiq
-  class WebAction
-    RACK_SESSION = 'rack.session'
+  class Web
+    ##
+    # These instance methods are available to all executing ERB
+    # templates.
+    class Action
+      attr_accessor :env, :block
+
+      def initialize(env, block)
+        @_erb = false
+        @env = env
+        @block = block
+      end
 
-    attr_accessor :env, :block, :type
+      def config
+        env[:web_config]
+      end
 
-    def settings
-      Web.settings
-    end
+      def request
+        @request ||= ::Rack::Request.new(env)
+      end
 
-    def request
-      @request ||= ::Rack::Request.new(env)
-    end
+      def halt(res)
+        throw :halt, [res, {"content-type" => "text/plain"}, [res.to_s]]
+      end
 
-    def halt(res)
-      throw :halt, res
-    end
+      # external redirect
+      def redirect_to(url)
+        throw :halt, [302, {"location" => url}, []]
+      end
 
-    def redirect(location)
-      throw :halt, [302, { "Location" => "#{request.base_url}#{location}" }, []]
-    end
+      def header(key, value)
+        env["response_headers"][key] = value.to_s
+      end
 
-    def params
-      indifferent_hash = Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+      # internal redirect
+      def redirect(location)
+        throw :halt, [302, {"location" => "#{request.base_url}#{location}"}, []]
+      end
 
-      indifferent_hash.merge! request.params
-      route_params.each {|k,v| indifferent_hash[k.to_s] = v }
+      def reload_page
+        current_location = request.referer.gsub(request.base_url, "")
+        redirect current_location
+      end
 
-      indifferent_hash
-    end
+      # stuff after ? or form input
+      # uses String keys, no Symbols!
+      def url_params(key)
+        warn { "URL parameter `#{key}` should be accessed via String, not Symbol (at #{caller(3..3).first})" } if key.is_a?(Symbol)
+        request.params[key.to_s]
+      end
 
-    def route_params
-      env[WebRouter::ROUTE_PARAMS]
-    end
+      # variables embedded in path, `/metrics/:name`
+      # uses Symbol keys, no Strings!
+      def route_params(key)
+        warn { "Route parameter `#{key}` should be accessed via Symbol, not String (at #{caller(3..3).first})" } if key.is_a?(String)
+        env["rack.route_params"][key.to_sym]
+      end
 
-    def session
-      env[RACK_SESSION]
-    end
+      def params
+        warn { "Direct access to Rack parameters is discouraged, use `url_params` or `route_params` (at #{caller(3..3).first})" }
+        request.params
+      end
 
-    def erb(content, options = {})
-      if content.kind_of? Symbol
-        unless respond_to?(:"_erb_#{content}")
-          src = ERB.new(File.read("#{Web.settings.views}/#{content}.erb")).src
-          WebAction.class_eval("def _erb_#{content}\n#{src}\n end")
-        end
+      def session
+        env["rack.session"]
       end
 
-      if @_erb
-        _erb(content, options[:locals])
-      else
-        @_erb = true
-        content = _erb(content, options[:locals])
+      def logger
+        Sidekiq.logger
+      end
 
-        _render { content }
+      # flash { "Some message to show on redirect" }
+      def flash
+        msg = yield
+        logger.info msg
+        session[:flash] = msg
       end
-    end
 
-    def render(engine, content, options = {})
-      raise "Only erb templates are supported" if engine != :erb
+      def flash?
+        session&.[](:flash)
+      end
 
-      erb(content, options)
-    end
+      def get_flash
+        @flash ||= session.delete(:flash)
+      end
 
-    def json(payload)
-      [200, { "Content-Type" => "application/json", "Cache-Control" => "no-cache" }, [Sidekiq.dump_json(payload)]]
-    end
+      def erb(content, options = {})
+        if content.is_a? Symbol
+          unless respond_to?(:"_erb_#{content}")
+            views = options[:views] || Web.views
+            filename = "#{views}/#{content}.erb"
+            src = ERB.new(File.read(filename)).src
+
+            # Need to use lineno less by 1 because erb generates a
+            # comment before the source code.
+            Action.class_eval <<-RUBY, filename, -1 # standard:disable Style/EvalWithLocation
+              def _erb_#{content}
+                #{src}
+              end
+            RUBY
+          end
+        end
 
-    def initialize(env, block)
-      @_erb = false
-      @env = env
-      @block = block
-      @@files ||= {}
-    end
+        if @_erb
+          _erb(content, options[:locals])
+        else
+          @_erb = true
+          content = _erb(content, options[:locals])
+
+          _render { content }
+        end
+      end
 
-    private
+      def render(engine, content, options = {})
+        raise "Only erb templates are supported" if engine != :erb
 
-    def _erb(file, locals)
-      locals.each {|k, v| define_singleton_method(k){ v } unless (singleton_methods.include? k)} if locals
+        erb(content, options)
+      end
+
+      def json(payload)
+        [200,
+          {"content-type" => "application/json", "cache-control" => "private, no-store"},
+          [Sidekiq.dump_json(payload)]]
+      end
+
+      private
+
+      def warn
+        Sidekiq.logger.warn yield
+      end
+
+      def _erb(file, locals)
+        locals&.each { |k, v| define_singleton_method(k) { v } unless singleton_methods.include? k }
 
-      if file.kind_of?(String)
-        ERB.new(file).result(binding)
-      else
-        send(:"_erb_#{file}")
+        if file.is_a?(String)
+          ERB.new(file).result(binding)
+        else
+          send(:"_erb_#{file}")
+        end
       end
+
+      class_eval <<-RUBY, ::Sidekiq::Web::LAYOUT, -1 # standard:disable Style/EvalWithLocation
+        def _render
+          #{ERB.new(File.read(::Sidekiq::Web::LAYOUT)).src}
+        end
+      RUBY
     end
   end
 end