ultra-lite-hub 0.0.1

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

@@ -0,0 +1,89 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The assets_preloading plugin generates html tags or a header value
+    # to facilitate browser preloading of your assets. This allows
+    # compatible browsers to fetch assets before they are required,
+    # streamlining page rendering.
+    #
+    # For a list of compatible browsers, see
+    # http://caniuse.com/#search=link-rel-preload
+    #
+    # The plugin provides two functions - preload_assets_link_header and
+    # preload_assets_link_tags. The resulting preloading should be
+    # identical, it is up to you which system you prefer.
+    #
+    # preload_assets_link_header returns a string suitable for populating
+    # the response Link header:
+    #
+    #   response.headers['Link'] = preload_assets_link_header(:css)
+    #   # Link header will now contain something like:
+    #   # </assets/app.css>;rel="preload";as="style"
+    #
+    # preload_assets_link_tags returns a string to drop into your
+    # templates containing link tags:
+    #
+    #   preload_assets_link_tags(:css)
+    #   # returns <link href="/assets/app.css" rel="preload" as="style">
+    #
+    # Note that these link tags are different to the usual asset
+    # declarations in markup; this will only instruct a compatible browser
+    # to fetch the file and cache it for later; the browser will not parse
+    # the asset until it encounters a traditional link or script tag.
+    #
+    # You must still setup and link to your assets as you did previously.
+    #
+    # Both functions can be passed any combination of asset types or
+    # asset groups, as multiple arguments:
+    #
+    #   # generate tags for css assets and the app js asset group
+    #   preload_assets_link_tags(:css, [:js, :app], [:js, :bar])
+    #
+    #   # generate Link header for css assets and js asset groups app and bar
+    #   preload_assets_link_header(:css, [:js, :app])
+    #
+    module AssetsPreloading
+      TYPE_AS = {
+        :css => 'style'.freeze,
+        :js => 'script'.freeze,
+      }.freeze
+
+      # Depend on the assets plugin, as we'll be calling some functions in it.
+      def self.load_dependencies(app)
+        app.plugin :assets
+      end
+
+      module InstanceMethods
+        # Return a string of <link> tags for the given asset
+        # types/groups.
+        def preload_assets_link_tags(*args)
+          _preload_assets_array(args).map{|path, as| "<link href=\"#{h(path)}\" rel=\"preload\" as=\"#{as}\">"}.join("\n")
+        end
+
+        # Return a string suitable for a Link header for the
+        # given asset types/groups.
+        def preload_assets_link_header(*args)
+          _preload_assets_array(args).map{|path, as| "<#{path}>;rel=preload;as=#{as}"}.join(",")
+        end
+
+        private
+
+        # Return an array of paths/as pairs for the given asset
+        # types and/or groups.
+        def _preload_assets_array(assets)
+          assets.flat_map do |type|
+            paths = assets_paths(type)
+            type = type[0] if type.is_a?(Array)
+            as = TYPE_AS[type]
+
+            paths.map{|path| [path, as]}
+          end
+        end
+      end
+    end
+
+    register_plugin(:assets_preloading, AssetsPreloading)
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The assume_ssl plugin makes the request ssl? method always return
+    # true. This is useful when using an SSL-terminating reverse proxy
+    # that doesn't set the X-Forwarded-Proto or similar header to notify
+    # Rack that it is forwarding an SSL request.
+    #
+    # The sessions and sinatra_helpers plugins that ship with Roda both
+    # use the ssl? method internally and can be affected by use of the
+    # plugin.  It's recommended that you use this plugin if you are
+    # using either plugin and an SSL-terminating proxy as described above.
+    #
+    #   plugin :assume_ssl
+    module AssumeSSL
+      module RequestMethods
+        # Assume all requests are protected by SSL.
+        def ssl?
+          true
+        end
+      end
+    end
+
+    register_plugin(:assume_ssl, AssumeSSL)
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The autoload_hash_branches plugin builds on the hash_branches plugin and allows for
+    # delaying loading of a file containing a hash branch for an application until there
+    # is a request that uses the hash branch. This can be useful in development
+    # to improvement startup time by not loading all branches up front.  It can also be
+    # useful in testing subsets of an application by only loading the hash branches being
+    # tested.
+    #
+    # You can specify a single hash branch for autoloading:
+    #
+    #   plugin :autoload_hash_branches
+    #   autoload_hash_branch('branch_name', '/absolute/path/to/file')
+    #   autoload_hash_branch('namespace', 'branch_name', 'relative/path/to/file')
+    #
+    # You can also set the plugin to autoload load all hash branch files in a given directory.
+    # This will look at each .rb file in the directory, and add an autoload for it, using the
+    # filename without the .rb as the branch name:
+    #
+    #   autoload_hash_branch_dir('/path/to/dir')
+    #   autoload_hash_branch_dir('namespace', '/path/to/dir')
+    #
+    # In both cases, when the autoloaded file is required, it should redefine the same
+    # hash branch.  If it does not, requests to the hash branch will result in a 404 error.
+    #
+    # When freezing an application, all hash branches are automatically loaded, because
+    # autoloading hash branches does not work for frozen applications.
+    module AutoloadHashBranches
+      def self.load_dependencies(app)
+        app.plugin :hash_branches
+      end
+
+      def self.configure(app)
+        app.opts[:autoload_hash_branch_files] ||= []
+      end
+
+      module ClassMethods
+        # Autoload the given file when there is request for the hash branch.
+        # The given file should configure the hash branch specified.
+        def autoload_hash_branch(namespace='', segment, file)
+          segment = "/#{segment}"
+          file = File.expand_path(file)
+          opts[:autoload_hash_branch_files] << file
+          routes = opts[:hash_branches][namespace] ||= {}
+          meth = routes[segment] = define_roda_method(routes[segment] || "hash_branch_#{namespace}_#{segment}", 1) do |r|
+            loc = method(routes[segment]).source_location
+            require file
+            # Avoid infinite loop in case method is not overridden
+            if method(meth).source_location != loc
+              send(meth, r)
+            end
+          end
+          nil
+        end
+
+        # For each .rb file in the given directory, add an autoloaded hash branch
+        # based on the file name.
+        def autoload_hash_branch_dir(namespace='', dir)
+          Dir.new(dir).entries.each do |file|
+            if file =~ /\.rb\z/i
+              autoload_hash_branch(namespace, file.sub(/\.rb\z/i, ''), File.join(dir, file))
+            end
+          end
+        end
+
+        # Eagerly load all hash branches when freezing the application.
+        def freeze
+          opts.delete(:autoload_hash_branch_files).each{|file| require file} unless opts.frozen?
+          super
+        end
+      end
+    end
+
+    register_plugin(:autoload_hash_branches, AutoloadHashBranches)
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The autoload_named_routes plugin builds on the named_routes plugin and allows for
+    # delaying loading of a file containing a named route for an application until there
+    # is a request that uses the named route. This can be useful in development
+    # to improvement startup time by not loading all named routes up front.  It can also be
+    # useful in testing subsets of an application by only loading the named routes being
+    # tested.
+    #
+    # You can specify a single hash branch for autoloading:
+    #
+    #   plugin :autoload_named_route
+    #   autoload_named_route(:route_name, '/absolute/path/to/file')
+    #   autoload_named_route(:namespace, :route_name, 'relative/path/to/file')
+    #
+    # Note that unlike the +route+ method defined by the named_routes plugin, when providing
+    # a namespace, the namespace comes before the route name and not after.
+    #
+    # When the autoloaded file is required, it should redefine the same
+    # named route.  If it does not, requests to the named route will be ignored (as if the
+    # related named route block was empty).
+    #
+    # When freezing an application, all named routes are automatically loaded, because
+    # autoloading named routes does not work for frozen applications.
+    module AutoloadNamedRoutes
+      def self.load_dependencies(app)
+        app.plugin :named_routes
+      end
+
+      def self.configure(app)
+        app.opts[:autoload_named_route_files] ||= []
+      end
+
+      module ClassMethods
+        # Autoload the given file when there is request for the named route.
+        # The given file should configure the named route specified.
+        def autoload_named_route(namespace=nil, name, file)
+          file = File.expand_path(file)
+          opts[:autoload_named_route_files] << file
+          routes = opts[:namespaced_routes][namespace] ||= {}
+          meth = routes[name] = define_roda_method(routes[name] || "named_routes_#{namespace}_#{name}", 1) do |r|
+            loc = method(routes[name]).source_location
+            require file
+            # Avoid infinite loop in case method is not overridden
+            if method(meth).source_location != loc
+              send(meth, r)
+            end
+          end
+          nil
+        end
+
+        # Eagerly load all autoloaded named routes when freezing the application.
+        def freeze
+          opts.delete(:autoload_named_route_files).each{|file| require file} unless opts.frozen?
+          super
+        end
+      end
+    end
+
+    register_plugin(:autoload_named_routes, AutoloadNamedRoutes)
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The backtracking_array plugin changes the handling of array
+    # matchers such that if one of the array entries matches, but
+    # a later match argument fails, it will backtrack and try the
+    # next entry in the array.  For example, the following match
+    # block does not match +/a/b+ by default:
+    #
+    #   r.is ['a', 'a/b'] do |path|
+    #     # ...
+    #   end
+    #
+    # This is because the <tt>'a'</tt> entry in the array matches, which
+    # makes the array match.  However, the next matcher is the
+    # terminal matcher (since +r.is+ was used), and since the
+    # path is not terminal as it still contains +/b+ after
+    # matching <tt>'a'</tt>.
+    #
+    # With the backtracking_array plugin, when the terminal matcher
+    # fails, matching will go on to the next entry in the array,
+    # <tt>'a/b'</tt>, which will also match.  Since <tt>'a/b'</tt>
+    # matches the path fully, the terminal matcher also matches,
+    # and the match block yields.
+    module BacktrackingArray
+      module RequestMethods
+        private
+
+        # When matching for a single array, after a successful
+        # array element match, attempt to match all remaining
+        # elements.  If the remaining elements could not be
+        # matched, reset the state and continue to the next
+        # entry in the array.
+        def _match_array(arg, rest)
+          path = @remaining_path
+          captures = @captures
+          caps = captures.dup
+          arg.each do |v|
+            if match(v, rest)
+              if v.is_a?(String)
+                captures.push(v)
+              end
+
+              if match_all(rest)
+                return true
+              end
+
+              # Matching all remaining elements failed, reset state
+              captures.replace(caps)
+              @remaining_path = path
+            end
+          end
+          false
+        end
+
+        # If any of the args are an array, handle backtracking such
+        # that if a later matcher fails, we roll back to the current
+        # matcher and proceed to the next entry in the array.
+        def match_all(args)
+          args = args.dup
+          until args.empty?
+            arg = args.shift
+            if match(arg, args)
+              return true if arg.is_a?(Array)
+            else
+              return
+            end
+          end
+          true
+        end
+
+        # When matching an array, include the remaining arguments,
+        # otherwise, just match the single argument.
+        def match(v, rest = nil)
+          if v.is_a?(Array)
+            _match_array(v, rest)
+          else
+            super(v)
+          end
+        end
+      end
+    end
+
+    register_plugin(:backtracking_array, BacktrackingArray)
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The bearer_token plugin adds an +r.bearer_token+ method for retrieving
+    # a bearer token from the +Authorization+ HTTP header. Bearer tokens will
+    # in the authorization header will be recognized as long as they start
+    # with the case insensitive string "bearer ".
+    module BearerToken
+      # :nocov:
+      METHOD = RUBY_VERSION >= "2.4" ? :match? : :match
+      # :nocov:
+
+      module RequestMethods
+        # Return the bearer token for the request if there is one in the
+        # authorization HTTP header.
+        def bearer_token
+          if (auth = @env["HTTP_AUTHORIZATION"]) && auth.send(METHOD, /\Abearer /i)
+            auth[7, 100000000]
+          end
+        end
+      end
+    end
+
+    register_plugin(:bearer_token, BearerToken)
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The branch_locals plugin allows you to override view and layout
+    # locals for specific branches and routes.
+    #
+    #   plugin :render
+    #   plugin :render_locals, render: {footer: 'Default'}, layout: {title: 'Main'}
+    #   plugin :branch_locals
+    #
+    #   route do |r|
+    #     r.on "users" do
+    #       set_layout_locals title: 'Users'
+    #       set_view_locals footer: '(c) Roda'
+    #     end
+    #   end
+    #
+    # The locals you specify in the set_layout_locals and set_view_locals methods
+    # have higher precedence than the render_locals plugin options, but lower precedence
+    # than options you directly pass to the view/render methods.
+    module BranchLocals
+      # Load the render_locals plugin before this plugin, since this plugin
+      # works by overriding methods in the render_locals plugin.
+      def self.load_dependencies(app)
+        app.plugin :render_locals
+      end
+
+      module InstanceMethods
+        # Update the default layout locals to use in this branch.
+        def set_layout_locals(opts)
+          if locals = @_layout_locals
+            @_layout_locals = locals.merge(opts)
+          else
+            @_layout_locals = opts
+          end
+        end
+
+        # Update the default view locals to use in this branch.
+        def set_view_locals(opts)
+          if locals = @_view_locals
+            @_view_locals = locals.merge(opts)
+          else
+            @_view_locals = opts
+          end
+        end
+
+        private
+
+        # Make branch specific view locals override render_locals plugin defaults.
+        def render_locals
+          locals = super
+          if @_view_locals
+            locals = Hash[locals].merge!(@_view_locals)
+          end
+          locals
+        end
+
+        # Make branch specific layout locals override render_locals plugin defaults.
+        def layout_locals
+          locals = super
+          if @_layout_locals
+            locals = Hash[locals].merge!(@_layout_locals)
+          end
+          locals
+        end
+      end
+    end
+
+    register_plugin(:branch_locals, BranchLocals)
+  end
+end
+

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

@@ -0,0 +1,43 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The break plugin supports calling break inside a match block, to
+    # return from the block and continue in the routing tree, restoring
+    # the remaining path so that future matchers operating on the path
+    # operate as expected.
+    #
+    #   plugin :break
+    #
+    #   route do |r|
+    #     r.on "foo", :bar do |bar|
+    #       break if bar == 'baz'
+    #       "/foo/#{bar} (not baz)"
+    #     end
+    #
+    #     r.on "foo/baz" do
+    #       "/foo/baz"
+    #     end
+    #   end
+    #
+    # This provides the same basic feature as the pass plugin, but
+    # uses Ruby's standard control flow primative instead of a
+    # separate method.
+    module Break
+      module RequestMethods
+        private
+
+        # Handle break inside match blocks, restoring remaining path.
+        def if_match(_)
+          rp = @remaining_path
+          super
+        ensure
+          @remaining_path = rp
+        end
+      end
+    end
+
+    register_plugin(:break, Break)
+  end
+end