ultra-max-sys 0.0.1

data/roda-3.106.0/lib/roda/plugins/json_parser.rb

@@ -0,0 +1,107 @@
+# frozen-string-literal: true
+
+require 'json'
+
+class Roda
+  module RodaPlugins
+    # The json_parser plugin parses request bodies in JSON format
+    # if the request's content type specifies json. This is mostly
+    # designed for use with JSON API sites.
+    #
+    # This only parses the request body as JSON if the Content-Type
+    # header for the request includes "json".
+    #
+    # The parsed JSON body will be available in +r.POST+, just as a
+    # parsed HTML form body would be. It will also be available in
+    # +r.params+ (which merges +r.GET+ with +r.POST+).
+    module JsonParser
+      DEFAULT_ERROR_HANDLER = proc{|r| r.halt [400, {}, []]}
+
+      # Handle options for the json_parser plugin:
+      # :error_handler :: A proc to call if an exception is raised when
+      #                   parsing a JSON request body.  The proc is called
+      #                   with the request object, and should probably call
+      #                   halt on the request or raise an exception.
+      # :parser :: The parser to use for parsing incoming json.  Should be
+      #            an object that responds to +call(str)+ and returns the
+      #            parsed data.  The default is to call JSON.parse.
+      # :include_request :: If true, the parser will be called with the request
+      #                     object as the second argument, so the parser needs
+      #                     to respond to +call(str, request)+.
+      # :wrap :: Whether to wrap uploaded JSON data in a hash with a "_json"
+      #          key.  Without this, calls to +r.params+ will fail if a non-Hash
+      #          (such as an array) is uploaded in JSON format.  A value of
+      #          :always will wrap all values, and a value of :unless_hash will
+      #          only wrap values that are not already hashes.
+      def self.configure(app, opts=OPTS)
+        app.opts[:json_parser_error_handler] = opts[:error_handler] || app.opts[:json_parser_error_handler] || DEFAULT_ERROR_HANDLER
+        app.opts[:json_parser_parser] = opts[:parser] || app.opts[:json_parser_parser] || app.opts[:json_parser] || JSON.method(:parse)
+        app.opts[:json_parser_include_request] = opts[:include_request] if opts.has_key?(:include_request)
+
+        case opts[:wrap]
+        when :unless_hash, :always
+          app.opts[:json_parser_wrap] = opts[:wrap]
+        when nil
+          # Nothing
+        else
+          raise RodaError, "unsupported option value for json_parser plugin :wrap option: #{opts[:wrap].inspect} (should be :unless_hash or :always)"
+        end
+      end
+
+      module RequestMethods
+        # If the Content-Type header in the request includes "json",
+        # parse the request body as JSON.  Ignore an empty request body.
+        def POST
+          env = @env
+          if post_params = env["roda.json_params"]
+            return post_params
+          end
+
+          unless (input = env["rack.input"]) && (content_type = self.content_type) && content_type.include?('json')
+            return super
+          end
+
+          str = _read_json_input(input)
+          return super if str.empty?
+          begin
+            json_params = parse_json(str)
+          rescue
+            roda_class.opts[:json_parser_error_handler].call(self)
+          end
+
+          wrap = roda_class.opts[:json_parser_wrap]
+          if wrap == :always || (wrap == :unless_hash && !json_params.is_a?(Hash))
+            json_params = {"_json"=>json_params}
+          end
+          env["roda.json_params"] = json_params
+          json_params
+        end
+
+        private
+
+        def parse_json(str)
+          args = [str]
+          args << self if roda_class.opts[:json_parser_include_request]
+          roda_class.opts[:json_parser_parser].call(*args)
+        end
+
+        
+        # Rack 3 dropped requirement that input be rewindable
+        if Rack.release >= '3'
+          def _read_json_input(input)
+            input.read
+          end
+        else
+          def _read_json_input(input)
+            input.rewind
+            str = input.read
+            input.rewind
+            str
+          end
+        end
+      end
+    end
+
+    register_plugin(:json_parser, JsonParser)
+  end
+end

data/roda-3.106.0/lib/roda/plugins/link_to.rb

@@ -0,0 +1,83 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The link_to plugin adds the +link_to+ instance method, which can be used for constructing
+    # HTML links (+a+ tag with +href+ attribute).
+    #
+    # The simplest usage of +link_to+ is passing the body and the location to link to as strings:
+    #
+    #   link_to("body", "/path")
+    #   # => "<a href=\"/path\">body</a>"
+    #
+    # The link_to plugin depends on the path plugin, and allows you to pass symbols for named paths:
+    #
+    #   # Class level
+    #   path :foo, "/path/to/too"
+    #
+    #   # Instance level
+    #   link_to("body", :foo)
+    #   # => "<a href=\"/path/to/foo\">body</a>"
+    #
+    # It also allows you to pass instances of classes that you have registered with the path plugin:
+    #
+    #   # Class level
+    #   A = Struct.new(:id)
+    #   path A do
+    #     "/path/to/a/#{id}"
+    #   end
+    #
+    #   # Instance level
+    #   link_to("body", A.new(1))
+    #   # => "<a href=\"/path/to/a/1\">body</a>"
+    #
+    # To set additional HTML attributes on the +a+ tag, you can pass them as an options hash:
+    #
+    #   link_to("body", "/path", foo: "bar")
+    #   # => "<a href=\"/path\" foo=\"bar\">body</a>"
+    #
+    # If the body is nil, it will be set to the same as the path:
+    #
+    #   link_to(nil, "/path")
+    #   # => "<a href=\"/path\">/path</a>"
+    #
+    # The plugin will automatically HTML escape the path and any HTML attribute values, using the h plugin:
+    #
+    #   link_to("body", "/path?a=1&b=2", foo: '"bar"')
+    #   # => "<a href=\"/path?a=1&amp;b=2\" foo=\"&quot;bar&quot;\">body</a>"
+    module LinkTo
+      def self.load_dependencies(app)
+        app.plugin :h
+        app.plugin :path
+      end
+
+      module InstanceMethods
+        # Return a string with an HTML +a+ tag with an +href+ attribute. See LinkTo
+        # module documentation for details.
+        def link_to(body, href, attributes=OPTS)
+          case href
+          when Symbol
+            href = public_send(:"#{href}_path")
+          when String
+            # nothing
+          else
+            href = path(href)
+          end
+
+          href = h(href)
+
+          body = href if body.nil?
+
+          buf = String.new << "<a href=\"#{href}\""
+          attributes.each do |k, v|
+            buf << " " << k.to_s << "=\"" << h(v) << "\""
+          end
+          buf << ">" << body << "</a>"
+        end
+      end
+    end
+
+    register_plugin(:link_to, LinkTo)
+  end
+end