ultra-lite-hub 0.0.1

data/roda-3.105.0/lib/roda/plugins/erb_h.rb

@@ -0,0 +1,43 @@
+# frozen-string-literal: true
+
+require 'erb/escape'
+
+#
+class Roda
+  module RodaPlugins
+    # The erb_h plugin adds an +h+ instance method that will HTML
+    # escape the input and return it. This is similar to the h
+    # plugin, but it uses erb/escape to implement the HTML escaping,
+    # which offers faster performance.
+    #
+    # To make sure that this speeds up applications using the h
+    # plugin, this depends on the h plugin, and overrides the
+    # h method.
+    #
+    # The following example will return "<foo>" as the body.
+    #
+    #   plugin :erb_h
+    #
+    #   route do |r|
+    #     h('<foo>')
+    #   end
+    #
+    # The faster performance offered by the erb_h plugin is due
+    # to erb/escape avoiding allocations if not needed (returning the
+    # input object if no escaping is needed).  That behavior change
+    # can cause problems if you mutate the result of the h method
+    # (which can mutate the input), or mutate the input of the h
+    # method after calling it (which can mutate the result).
+    module ErbH
+      def self.load_dependencies(app)
+        app.plugin :h
+      end
+
+      module InstanceMethods
+        define_method(:h, ERB::Escape.instance_method(:html_escape))
+      end
+    end
+
+    register_plugin(:erb_h, ErbH)
+  end
+end

data/roda-3.105.0/lib/roda/plugins/error_email.rb

@@ -0,0 +1,152 @@
+# frozen-string-literal: true
+
+require 'net/smtp'
+
+class Roda
+  module RodaPlugins
+    # The error_email plugin adds an +error_email+ instance method that
+    # send an email related to the exception.  This is most useful if you are
+    # also using the error_handler plugin:
+    #
+    #   plugin :error_email, to: 'to@example.com', from: 'from@example.com'
+    #   plugin :error_handler do |e|
+    #     error_email(e)
+    #     'Internal Server Error'
+    #   end
+    #
+    # It is similar to the error_mail plugin, except that it uses net/smtp
+    # directly instead of using the mail library.  If you are not already using the
+    # mail library in your application, it makes sense to use error_email
+    # instead of error_mail.
+    #
+    # Options:
+    #
+    # :filter :: Callable called with the key and value for each parameter, environment
+    #            variable, and session value.  If it returns true, the value of the
+    #            parameter is filtered in the email.
+    # :from :: The From address to use in the email (required)
+    # :headers :: A hash of additional headers to use in the email (default: empty hash)
+    # :host :: The SMTP server to use to send the email (default: localhost)
+    # :prefix :: A prefix to use in the email's subject line (default: no prefix)
+    # :to :: The To address to use in the email (required)
+    #
+    # The subject of the error email shows the exception class and message.
+    # The body of the error email shows the backtrace of the error and the
+    # request environment, as well the request params and session variables (if any).
+    # You can also call error_email with a plain string instead of an exception,
+    # in which case the string is used as the subject, and no backtrace is included.
+    #
+    # Note that emailing on every error as shown above is only appropriate
+    # for low traffic web applications.  For high traffic web applications,
+    # use an error reporting service instead of this plugin.
+    module ErrorEmail
+      DEFAULTS = {
+        :filter=>lambda{|k,v| false},
+        :headers=>OPTS,
+        :host=>'localhost',
+        # :nocov:
+        :emailer=>lambda{|h| Net::SMTP.start(h[:host]){|s| s.send_message(h[:message], h[:from], h[:to])}},
+        # :nocov:
+        :default_headers=>lambda do |h, e|
+          subject = if e.respond_to?(:message)
+            "#{e.class}: #{e.message}"
+          else
+            e.to_s
+          end
+          {'From'=>h[:from], 'To'=>h[:to], 'Subject'=>"#{h[:prefix]}#{subject}"}
+        end,
+        :body=>lambda do |s, e|
+          filter = s.opts[:error_email][:filter]
+          format = lambda do |h|
+            h = h.map{|k, v| "#{k.inspect} => #{filter.call(k, v) ? 'FILTERED' : v.inspect}"}
+            h.sort!
+            h.join("\n")
+          end 
+
+          begin
+            params = s.request.params
+            params = (format[params] unless params.empty?)
+          rescue
+            params = 'Invalid Parameters!'
+          end
+
+          message = String.new
+          message << <<END
+Path: #{s.request.path}
+
+END
+          if e.respond_to?(:backtrace)
+            message << <<END
+Backtrace:
+
+#{e.backtrace.join("\n")}
+END
+          end
+
+          message << <<END
+ENV:
+
+#{format[s.env]}
+END
+
+          if params
+            message << <<END
+
+Params:
+
+#{params}
+END
+          end
+
+          if s.env['rack.session']
+            message << <<END
+
+Session:
+
+#{format[s.session]}
+END
+          end
+
+          message
+        end
+      }.freeze
+
+      # Set default opts for plugin.  See ErrorEmail module RDoc for options.
+      def self.configure(app, opts=OPTS)
+        email_opts = app.opts[:error_email] ||= DEFAULTS
+        email_opts = email_opts.merge(opts)
+        email_opts[:headers] = email_opts[:headers].dup
+        unless email_opts[:to] && email_opts[:from]
+          raise RodaError, "must provide :to and :from options to error_email plugin"
+        end
+        app.opts[:error_email] = email_opts
+        app.opts[:error_email][:headers].freeze
+        app.opts[:error_email].freeze
+      end
+
+      module InstanceMethods
+        # Send an email for the given error.  +exception+ is usually an exception
+        # instance, but it can be a plain string which is used as the subject for
+        # the email.
+        def error_email(exception)
+          email_opts = self.class.opts[:error_email].dup
+          email_opts[:message] = error_email_content(exception)
+          email_opts[:emailer].call(email_opts)
+        end
+
+        # The content of the email to send, include the headers and the body.
+        # Takes the same argument as #error_email.
+        def error_email_content(exception)
+          email_opts = self.class.opts[:error_email]
+          headers = email_opts[:default_headers].call(email_opts, exception)
+          headers = headers.merge(email_opts[:headers])
+          headers = headers.map{|k,v| "#{k}: #{v.gsub(/\r?\n/m, "\r\n ")}"}.sort.join("\r\n")
+          body = email_opts[:body].call(self, exception)
+          "#{headers}\r\n\r\n#{body}"
+        end
+      end
+    end
+
+    register_plugin(:error_email, ErrorEmail)
+  end
+end

data/roda-3.105.0/lib/roda/plugins/error_handler.rb

@@ -0,0 +1,133 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The error_handler plugin adds an error handler to the routing,
+    # so that if routing the request raises an error, a nice error
+    # message page can be returned to the user.
+    # 
+    # You can provide the error handler as a block to the plugin:
+    #
+    #   plugin :error_handler do |e|
+    #     "Oh No!"
+    #   end
+    #
+    # Or later via the +error+ class method:
+    #
+    #   plugin :error_handler
+    #
+    #   error do |e|
+    #     "Oh No!"
+    #   end
+    #
+    # In both cases, the exception instance is passed into the block,
+    # and the block can return the request body via a string.
+    #
+    # If an exception is raised, a new response will be used, with the
+    # default status set to 500, before executing the error handler.
+    # The error handler can change the response status if necessary,
+    # as well set headers and/or write to the body, just like a regular
+    # request.  After the error handler returns a response, normal after
+    # processing of that response occurs, except that an exception during
+    # after processing is logged to <tt>env['rack.errors']</tt> but
+    # otherwise ignored. This avoids recursive calls into the
+    # error_handler.  Note that if the error_handler itself raises
+    # an exception, the exception will be raised without normal after
+    # processing.  This can cause some after processing to run twice
+    # (once before the error_handler is called and once after) if
+    # later after processing raises an exception.
+    #
+    # By default, this plugin handles StandardError and ScriptError.
+    # To override the exception classes it will handle, pass a :classes
+    # option to the plugin:
+    #
+    #   plugin :error_handler, classes: [StandardError, ScriptError, NoMemoryError]
+    module ErrorHandler
+      DEFAULT_ERROR_HANDLER_CLASSES = [StandardError, ScriptError].freeze
+
+      # If a block is given, automatically call the +error+ method on
+      # the Roda class with it.
+      def self.configure(app, opts={}, &block)
+        app.opts[:error_handler_classes] = (opts[:classes] || app.opts[:error_handler_classes] || DEFAULT_ERROR_HANDLER_CLASSES).dup.freeze
+
+        if block
+          app.error(&block)
+        end
+      end
+
+      module ClassMethods
+        # Install the given block as the error handler, so that if routing
+        # the request raises an exception, the block will be called with
+        # the exception in the scope of the Roda instance.
+        def error(&block)
+          define_method(:handle_error, &block)
+          alias_method(:handle_error, :handle_error)
+          private :handle_error
+        end
+      end
+
+      module InstanceMethods
+        # If an error occurs, set the response status to 500 and call
+        # the error handler. Old Dispatch API.
+        def call
+          # RODA4: Remove
+          begin
+            res = super
+          ensure
+            _roda_after(res)
+          end
+        rescue *opts[:error_handler_classes] => e
+          _handle_error(e)
+        end
+
+        # If an error occurs, set the response status to 500 and call
+        # the error handler. 
+        def _roda_handle_main_route
+          begin
+            res = super
+          ensure
+            _roda_after(res)
+          end
+        rescue *opts[:error_handler_classes] => e
+          _handle_error(e)
+        end
+
+        private
+
+        # Default empty implementation of _roda_after, usually
+        # overridden by Roda.def_roda_before.
+        def _roda_after(res)
+        end
+
+        # Handle the given exception using handle_error, using a default status
+        # of 500.  Run after hooks on the rack response, but if any error occurs
+        # when doing so, log the error using rack.errors and return the response.
+        def _handle_error(e)
+          res = @_response
+          res.send(:initialize)
+          res.status = 500
+          res = _roda_handle_route{handle_error(e)}
+          begin
+            _roda_after(res)
+          rescue => e2
+            if errors = env['rack.errors']
+              errors.puts "Error in after hook processing of error handler: #{e2.class}: #{e2.message}"
+              e2.backtrace.each{|line| errors.puts(line)}
+            end
+          end
+          res
+        end
+
+        # By default, have the error handler reraise the error, so using
+        # the plugin without installing an error handler doesn't change
+        # behavior.
+        def handle_error(e)
+          raise e
+        end
+      end
+    end
+
+    register_plugin(:error_handler, ErrorHandler)
+  end
+end

data/roda-3.105.0/lib/roda/plugins/error_mail.rb

@@ -0,0 +1,149 @@
+# frozen-string-literal: true
+
+require 'mail'
+
+class Roda
+  module RodaPlugins
+    # The error_mail plugin adds an +error_mail+ instance method that
+    # send an email related to the exception.  This is most useful if you are
+    # also using the error_handler plugin:
+    #
+    #   plugin :error_mail, to: 'to@example.com', from: 'from@example.com'
+    #   plugin :error_handler do |e|
+    #     error_mail(e)
+    #     'Internal Server Error'
+    #   end
+    #
+    # It is similar to the error_email plugin, except that it uses the mail
+    # library instead of net/smtp directly.  If you are already using the
+    # mail library in your application, it makes sense to use error_mail
+    # instead of error_email.
+    #
+    # Options:
+    #
+    # :filter :: Callable called with the key and value for each parameter, environment
+    #            variable, and session value.  If it returns true, the value of the
+    #            parameter is filtered in the email.
+    # :from :: The From address to use in the email (required)
+    # :headers :: A hash of additional headers to use in the email (default: empty hash)
+    # :prefix :: A prefix to use in the email's subject line (default: no prefix)
+    # :to :: The To address to use in the email (required)
+    #
+    # The subject of the error email shows the exception class and message.
+    # The body of the error email shows the backtrace of the error and the
+    # request environment, as well the request params and session variables (if any).
+    # You can also call error_mail with a plain string instead of an exception,
+    # in which case the string is used as the subject, and no backtrace is included.
+    #
+    # Note that emailing on every error as shown above is only appropriate
+    # for low traffic web applications.  For high traffic web applications,
+    # use an error reporting service instead of this plugin.
+    module ErrorMail
+      DEFAULT_FILTER = lambda{|k,v| false}
+      private_constant :DEFAULT_FILTER
+
+      # Set default opts for plugin.  See ErrorEmail module RDoc for options.
+      def self.configure(app, opts=OPTS)
+        app.opts[:error_mail] = email_opts = (app.opts[:error_mail] || {:filter=>DEFAULT_FILTER}).merge(opts).freeze
+        unless email_opts[:to] && email_opts[:from]
+          raise RodaError, "must provide :to and :from options to error_mail plugin"
+        end
+      end
+
+      module InstanceMethods
+        # Send an email for the given error.  +exception+ is usually an exception
+        # instance, but it can be a plain string which is used as the subject for
+        # the email.
+        def error_mail(exception)
+          _error_mail(exception).deliver!
+        end
+
+        # The content of the email to send, include the headers and the body.
+        # Takes the same argument as #error_mail.
+        def error_mail_content(exception)
+          _error_mail(exception).to_s
+        end
+
+        private
+
+        def _error_mail(e)
+          email_opts = self.class.opts[:error_mail]
+          subject = if e.respond_to?(:message)
+            "#{e.class}: #{e.message}"
+          else
+            e.to_s
+          end
+          subject = "#{email_opts[:prefix]}#{subject}"
+          filter = email_opts[:filter]
+
+          format = lambda do |h|
+            h = h.map{|k, v| "#{k.inspect} => #{filter.call(k, v) ? 'FILTERED' : v.inspect}"}
+            h.sort!
+            h.join("\n")
+          end 
+
+          begin
+            params = request.params
+            params = (format[params] unless params.empty?)
+          rescue
+            params = 'Invalid Parameters!'
+          end
+
+          message = String.new
+          message << <<END
+Path: #{request.path}
+
+END
+          if e.respond_to?(:backtrace)
+            message << <<END
+Backtrace:
+
+#{e.backtrace.join("\n")}
+END
+          end
+
+          message << <<END
+
+ENV:
+
+#{format[env]}
+END
+
+          if params
+            message << <<END
+
+Params:
+
+#{params}
+END
+          end
+
+          if env['rack.session']
+            message << <<END
+
+Session:
+
+#{format[session]}
+END
+          end
+
+
+          Mail.new do
+            from email_opts[:from]
+            to email_opts[:to]
+            subject subject
+            body message
+
+            if headers = email_opts[:headers]
+              headers.each do |k,v|
+                header[k] = v
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:error_mail, ErrorMail)
+  end
+end