ultra-max-sys 0.0.1

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

@@ -0,0 +1,340 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # A permissions_policy plugin has been added that allows you to easily set a
+    # Permissions-Policy header for the application, which browsers can use to
+    # determine whether to allow specific functionality on the returned page
+    # (mainly related to which JavaScript APIs the page is allowed to use).
+    #
+    # You would generally call the plugin with a block to set the default policy:
+    #
+    #   plugin :permissions_policy do |pp|
+    #     pp.camera :none
+    #     pp.fullscreen :self
+    #     pp.clipboard_read :self, 'https://example.com'
+    #   end
+    #
+    # Then, anywhere in the routing tree, you can customize the policy for just that
+    # branch or action using the same block syntax:
+    #
+    #   r.get 'foo' do
+    #     permissions_policy do |pp|
+    #       pp.camera :self
+    #     end
+    #     # ...
+    #   end
+    #
+    # In addition to using a block, you can also call methods on the object returned
+    # by the method:
+    #
+    #   r.get 'foo' do
+    #     permissions_policy.camera :self
+    #     # ...
+    #   end
+    #
+    # You can use the :default plugin option to set the default for all settings.
+    # For example, to disallow all access for each setting by default:
+    #
+    #   plugin :permissions_policy, default: :none
+    #
+    # The following methods are available for configuring the permissions policy,
+    # which specify the setting (substituting _ with -): 
+    #
+    # * accelerometer
+    # * ambient_light_sensor
+    # * autoplay
+    # * bluetooth
+    # * camera
+    # * clipboard_read
+    # * clipboard_write
+    # * display_capture
+    # * encrypted_media
+    # * fullscreen
+    # * geolocation
+    # * gyroscope
+    # * hid
+    # * idle_detection
+    # * keyboard_map
+    # * magnetometer
+    # * microphone
+    # * midi
+    # * payment
+    # * picture_in_picture
+    # * publickey_credentials_get
+    # * screen_wake_lock
+    # * serial
+    # * sync_xhr
+    # * usb
+    # * web_share
+    # * window_management
+    #
+    # All of these methods support any number of arguments, and each argument should
+    # be one of the following values:
+    #
+    # :all :: Grants permission to all domains (must be only argument)
+    # :none :: Does not allow permission at all (must be only argument)
+    # :self :: Allows feature in current document and any nested browsing contexts
+    #          that use the same domain as the current document.
+    # :src :: Allows feature in current document and any nested browsing contexts
+    #         that use the same domain as the src of the iframe.
+    # String :: Specifies origin domain where access is allowed
+    #
+    # When calling a method with no arguments, the setting is removed from the policy instead
+    # of being left empty, since all of these setting require at least one value.  Likewise,
+    # if the policy does not have any settings, the header will not be added.
+    #
+    # Calling the method overrides any previous setting.  Each of the methods has +add_*+ and
+    # +get_*+ methods defined. The +add_*+ method appends to any existing setting, and the +get_*+ method
+    # returns the current value for the setting (this will be +:all+ if all domains are allowed, or
+    # any array of strings/:self/:src).
+    #
+    #   permissions_policy.fullscreen :self, 'https://example.com'
+    #   # fullscreen (self "https://example.com")
+    #
+    #   permissions_policy.add_fullscreen 'https://*.example.com'
+    #   # fullscreen (self "https://example.com" "https://*.example.com")
+    #
+    #   permissions_policy.get_fullscreen
+    #   # => [:self, "https://example.com", "https://*.example.com"]
+    #
+    # The clear method can be used to remove all settings from the policy. Empty policies
+    # do not set any headers. You can use +response.skip_permissions_policy!+ to skip
+    # setting a policy.  This is faster than calling +permissions_policy.clear+, since
+    # it does not duplicate the default policy.
+    module PermissionsPolicy
+      RESPONSE_INSTANCE_VARIABLES = [:@permissions_policy, :@skip_permissions_policy].freeze
+
+      SUPPORTED_SETTINGS = %w'
+      accelerometer
+      ambient-light-sensor
+      autoplay
+      bluetooth
+      camera
+      clipboard-read
+      clipboard-write
+      display-capture
+      encrypted-media
+      fullscreen
+      geolocation
+      gyroscope
+      hid
+      idle-detection
+      keyboard-map
+      magnetometer
+      microphone
+      midi
+      payment
+      picture-in-picture
+      publickey-credentials-get
+      screen-wake-lock
+      serial
+      sync-xhr
+      usb
+      web-share
+      window-management
+      '.each(&:freeze).freeze
+      private_constant :SUPPORTED_SETTINGS
+
+      # Represents a permissions policy.
+      class Policy
+        SUPPORTED_SETTINGS.each do |setting|
+          meth = setting.tr('-', '_').freeze
+
+          # Setting method name sets the setting value, or removes it if no args are given.
+          define_method(meth) do |*args|
+            if args.empty?
+              @opts.delete(setting)
+            else
+              @opts[setting] = option_value(args)
+            end
+            nil
+          end
+
+          # add_* method name adds to the setting value, or clears setting if no values
+          # are given.
+          define_method(:"add_#{meth}") do |*args|
+            unless args.empty?
+              case v = @opts[setting]
+              when :all
+                # If all domains are already allowed, there is no reason to add more.
+                return
+              when Array
+                @opts[setting] = option_value(v + args)
+              else
+                @opts[setting] = option_value(args)
+              end
+            end
+            nil
+          end
+
+          # get_* method always returns current setting value.
+          define_method(:"get_#{meth}") do
+            @opts[setting]
+          end
+        end
+
+        def initialize
+          clear
+        end
+
+        # Clear all settings, useful to remove any inherited settings.
+        def clear
+          @opts = {}
+          @report_only = nil
+          @header_value = nil
+        end
+
+        # Do not allow future modifications to any settings.
+        def freeze
+          @opts.freeze
+          header_value.freeze
+          super
+        end
+
+        # The header name to use, depends on whether report only mode has been enabled.
+        def header_key
+          @report_only ? RodaResponseHeaders::PERMISSIONS_POLICY_REPORT_ONLY : RodaResponseHeaders::PERMISSIONS_POLICY
+        end
+
+        # The header value to use.
+        def header_value
+          return @header_value if @header_value
+
+          s = String.new
+          @opts.each do |k, vs|
+            s << k << "="
+
+            if vs == :all
+              s << '*, '
+            else
+              s << '('
+              vs.each{|v| append_formatted_value(s, v)}
+              s.chop! unless vs.empty?
+              s << '), '
+            end
+          end
+          s.chop!
+          s.chop!
+          @header_value = s
+        end
+
+        # Set whether the Permissions-Policy-Report-Only header instead of the
+        # default Permissions-Policy header.
+        def report_only(report=true)
+          @report_only = report
+        end
+
+        # Whether this policy uses report only mode.
+        def report_only?
+          !!@report_only
+        end
+
+        # Set the current policy in the headers hash.  If no settings have been made
+        # in the policy, does not set a header.
+        def set_header(headers)
+          return if @opts.empty?
+          headers[header_key] ||= header_value
+        end
+
+        private
+
+        # Formats nested values, quoting strings and using :self and :src verbatim.
+        def append_formatted_value(s, v)
+          case v
+          when String
+            s << v.inspect << ' '
+          when :self
+            s << 'self '
+          when :src
+            s << 'src '
+          else
+            raise RodaError, "unsupported Permissions-Policy item value used: #{v.inspect}"
+          end
+        end
+
+        # Make object copy use copy of settings, and remove cached header value.
+        def initialize_copy(_)
+          super
+          @opts = @opts.dup
+          @header_value = nil
+        end
+
+        # The option value to store for the given args.
+        def option_value(args)
+          if args.length == 1
+            case args[0]
+            when :all
+              :all
+            when :none
+              EMPTY_ARRAY
+            else
+              args.freeze
+            end
+          else
+            args.freeze
+          end
+        end
+      end
+
+      # Yield the current Permissions Policy to the block.
+      def self.configure(app, opts=OPTS)
+        policy = app.opts[:permissions_policy] = if policy = app.opts[:permissions_policy]
+          policy.dup
+        else
+          Policy.new
+        end
+
+        if default = opts[:default]
+          SUPPORTED_SETTINGS.each do |setting|
+            policy.send(setting.tr('-', '_'), *default)
+          end
+        end
+
+        yield policy if defined?(yield)
+        policy.freeze
+      end
+
+      module InstanceMethods
+        # If a block is given, yield the current permission policy.  Returns the
+        # current permissions policy.
+        def permissions_policy
+          policy = @_response.permissions_policy
+          yield policy if defined?(yield)
+          policy
+        end
+      end
+
+      module ResponseMethods
+        # Unset any permissions policy when reinitializing
+        def initialize
+          super
+          @permissions_policy &&= nil
+        end
+
+        # The current permissions policy to be used for this response.
+        def permissions_policy
+          @permissions_policy ||= roda_class.opts[:permissions_policy].dup
+        end
+
+        # Do not set a permissions policy header for this response.
+        def skip_permissions_policy!
+          @skip_permissions_policy = true
+        end
+
+        private
+
+        # Set the appropriate permissions policy header.
+        def set_default_headers
+          super
+          unless @skip_permissions_policy
+            (@permissions_policy || roda_class.opts[:permissions_policy]).set_header(headers)
+          end
+        end
+      end
+    end
+
+    register_plugin(:permissions_policy, PermissionsPolicy)
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The placeholder_string_matcher plugin exists for backwards compatibility
+    # with previous versions of Roda that allowed placeholders inside strings
+    # if they were prefixed by colons:
+    #
+    #   plugin :placeholder_string_matchers
+    #
+    #   route do |r|
+    #     r.is("foo/:bar") |v|
+    #       # matches foo/baz, yielding "baz"
+    #       # does not match foo, foo/, or foo/baz/
+    #     end
+    #   end
+    #
+    # It is not recommended to use this in new applications, and it is encouraged
+    # to use separate string class or symbol matchers instead:
+    #
+    #   r.is "foo", String
+    #   r.is "foo", :bar 
+    #
+    # If used with the symbol_matchers plugin, this plugin respects the regexps
+    # for the registered symbols, but it does not perform the conversions, the
+    # captures for the regexp are used directly as the captures for the match method.
+    module PlaceholderStringMatchers
+      def self.load_dependencies(app)
+        app.plugin :_symbol_regexp_matchers
+      end
+
+      module RequestMethods
+        private
+
+        def _match_string(str)
+          if str.index(":")
+            consume(self.class.cached_matcher(str){Regexp.escape(str).gsub(/:(\w+)/){|m| _match_symbol_regexp($1)}})
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:placeholder_string_matchers, PlaceholderStringMatchers)
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The plain_hash_response_headers plugin will change Roda to
+    # use a plain hash for response headers.  This is Roda's
+    # default behavior on Rack 2, but on Rack 3+, Roda defaults
+    # to using Rack::Headers for response headers for backwards
+    # compatibility (Rack::Headers automatically lower cases header
+    # keys).
+    #
+    # On Rack 3+, you should use this plugin for better performance
+    # if you are sure all headers in your application and middleware
+    # are already lower case (lower case response header keys are
+    # required by the Rack 3 spec).
+    module PlainHashResponseHeaders
+      if defined?(Rack::Headers) && Rack::Headers.is_a?(Class)
+        module ResponseMethods
+          private
+
+          # Use plain hash for headers
+          def _initialize_headers
+            {}
+          end
+        end
+      end
+    end
+
+    register_plugin(:plain_hash_response_headers, PlainHashResponseHeaders)
+  end
+end

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

@@ -0,0 +1,156 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The precompile_templates plugin adds support for precompiling template code.
+    # This can result in a large memory savings for applications that have large
+    # templates or a large number of small templates if the application uses a
+    # forking webserver.  By default, template compilation is lazy, so all the
+    # child processes in a forking webserver will have their own copy of the
+    # compiled template.  By using the precompile_templates plugin, you can
+    # precompile the templates in the parent process before forking, and then
+    # all of the child processes can use the same precompiled templates, which
+    # saves memory.
+    #
+    # Another advantage of the precompile_templates plugin is that after
+    # template precompilation, access to the template file in the file system is
+    # no longer needed, so this can be used with security features that do not
+    # allow access to the template files at runtime.
+    #
+    # After loading the plugin, you should call precompile_views with an array
+    # of views to compile, using the same argument you are passing to view or
+    # render:
+    #
+    #   plugin :precompile_templates
+    #   precompile_views %w'view1 view2'
+    #   
+    # If the view requires local variables, you should call precompile_views with a second
+    # argument for the local variables:
+    #
+    #   plugin :precompile_templates
+    #   precompile_views :view3, [:local_var1, :local_var2]
+    #
+    # After all templates are precompiled, you can optionally use freeze_template_caches!,
+    # which will freeze the template caches so that any template compilation at runtime
+    # will result in an error.  This also speeds up template cache access, since the
+    # template caches no longer need a mutex.
+    #
+    #   freeze_template_caches!
+    #
+    # Note that you should use Tilt 2.0.1+ if you are using this plugin, so
+    # that locals are handled in the same order.
+    module PrecompileTemplates
+      # Load the render plugin as precompile_templates depends on it.
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :render
+      end
+
+      module ClassMethods
+        # Freeze the template caches.  Should be called after precompiling all templates during
+        # application startup, if you don't want to allow templates to be cached at runtime.
+        # In addition to ensuring that no templates are compiled at runtime, this also speeds
+        # up rendering by freezing the template caches, so that a mutex is not needed to access
+        # them.
+        def freeze_template_caches!
+          _freeze_layout_method
+
+          opts[:render] = render_opts.merge(
+            :cache=>render_opts[:cache].freeze,
+            :template_method_cache=>render_opts[:template_method_cache].freeze,
+          ).freeze
+          self::RodaCompiledTemplates.freeze
+
+          nil
+        end
+
+        # Precompile the templates using the given options.  Note that this doesn't
+        # handle optimized template methods supported in newer versions of Roda, but
+        # there are still cases where makes sense to use it.
+        #
+        # You can call +precompile_templates+ with the pattern of templates you would
+        # like to precompile:
+        #
+        #   precompile_templates "views/**/*.erb"
+        #
+        # That will precompile all erb template files in the views directory or
+        # any subdirectory.
+        #
+        # If the templates use local variables, you need to specify which local
+        # variables to precompile, which should be an array of symbols:
+        #
+        #   precompile_templates 'views/users/_*.erb', locals: [:user]
+        #
+        # You can specify other render options when calling +precompile_templates+,
+        # including +:cache_key+, +:template_class+, and +:template_opts+.  If you
+        # are passing any of those options to render/view for the template, you
+        # should pass the same options when precompiling the template.
+        #
+        # To compile inline templates, just pass a single hash containing an :inline
+        # to +precompile_templates+:
+        #
+        #   precompile_templates inline: some_template_string
+        def precompile_templates(pattern, opts=OPTS)
+          if pattern.is_a?(Hash)
+            opts = pattern.merge(opts)
+          end
+
+          if locals = opts[:locals]
+            locals.sort!
+          else
+            locals = EMPTY_ARRAY
+          end
+
+          compile_opts = if pattern.is_a?(Hash)
+            [opts]
+          else
+            Dir[pattern].map{|file| opts.merge(:path=>File.expand_path(file, nil))}
+          end
+
+          instance = allocate
+          compile_opts.each do |compile_opt|
+            template = instance.send(:retrieve_template, compile_opt)
+            begin
+              Render.tilt_template_compiled_method(template, locals, self)
+            rescue NotImplementedError
+              # When freezing template caches, you may want to precompile a template for a
+              # template type that doesn't support template precompilation, just to populate
+              # the cache.  Tilt rescues NotImplementedError in this case, which we can ignore.
+              nil
+            end
+          end
+
+          nil
+        end
+
+        # Precompile the given views with the given locals, handling optimized template methods.
+        def precompile_views(views, locals=EMPTY_ARRAY)
+          instance = allocate
+          views = Array(views)
+
+          if locals.empty?
+            opts = OPTS
+          else
+            locals_hash = {}
+            locals.each{|k| locals_hash[k] = nil}
+            opts = {:locals=>locals_hash}
+          end
+
+          views.each do |view|
+            instance.send(:retrieve_template, instance.send(:render_template_opts, view, opts))
+          end
+
+          if locals_hash
+            views.each do |view|
+              instance.send(:_optimized_render_method_for_locals, view, locals_hash)
+            end
+          end
+
+          nil
+        end
+      end
+    end
+
+    register_plugin(:precompile_templates, PrecompileTemplates)
+  end
+end