ultra-lite-hub 0.0.1

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

@@ -0,0 +1,111 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The class_level_routing plugin adds routing methods at the class level, which can
+    # be used instead of or in addition to using the normal +route+ method to start the
+    # routing tree.  If a request is not matched by the normal routing tree, the class
+    # level routes will be tried.  This offers a more Sinatra-like API, while
+    # still allowing you to use a routing tree inside individual actions.
+    #
+    # Here's the first example from the README, modified to use the class_level_routing
+    # plugin:
+    #
+    #   class App < Roda
+    #     plugin :class_level_routing
+    #
+    #     # GET / request
+    #     root do
+    #       request.redirect "/hello"
+    #     end
+    #
+    #     # GET /hello/world request
+    #     get "hello/world" do
+    #       "Hello world!"
+    #     end
+    #
+    #     # /hello request
+    #     is "hello" do
+    #       # Set variable for both GET and POST requests
+    #       @greeting = 'Hello'
+    #
+    #       # GET /hello request
+    #       request.get do
+    #         "#{@greeting}!"
+    #       end
+    #
+    #       # POST /hello request
+    #       request.post do
+    #         puts "Someone said #{@greeting}!"
+    #         request.redirect
+    #       end
+    #     end
+    #   end
+    #
+    # When using the class_level_routing plugin with nested routes, you may also want to use the
+    # delegate plugin to delegate certain instance methods to the request object, so you don't have
+    # to continually use +request.+ in your routing blocks.
+    #
+    # Note that class level routing is implemented via a simple array of routes, so routing performance
+    # will degrade linearly as the number of routes increases.  For best performance, you should use
+    # the normal +route+ class method to define your routing tree.  This plugin does make it simpler to
+    # add additional routes after the routing tree has already been defined, though.
+    module ClassLevelRouting
+      # Initialize the class_routes array when the plugin is loaded.  Also, if the application doesn't
+      # currently have a routing block, setup an empty routing block so that things will still work if
+      # a routing block isn't added.
+      def self.configure(app)
+        app.opts[:class_level_routes] ||= []
+      end
+
+      module ClassMethods
+        # Define routing methods that will store class level routes.
+        [:root, :on, :is, :get, :post, :delete, :head, :options, :link, :patch, :put, :trace, :unlink].each do |request_meth|
+          define_method(request_meth) do |*args, &block|
+            meth = define_roda_method("class_level_routing_#{request_meth}", :any, &block)
+            opts[:class_level_routes] << [request_meth, args, meth].freeze
+          end
+        end
+
+        # Freeze the class level routes so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:class_level_routes].freeze
+          super
+        end
+      end
+
+      module InstanceMethods
+        def initialize(_)
+          super
+          @_original_remaining_path = @_request.remaining_path
+        end
+
+        private
+
+        # If the normal routing tree doesn't handle an action, try each class level route
+        # to see if it matches.
+        def _roda_after_10__class_level_routing(result)
+          if result && result[0] == 404 && (v = result[2]).is_a?(Array) && v.empty?
+            # Reset the response so it doesn't inherit the status or any headers from
+            # the original response.
+            @_response.send(:initialize)
+            @_response.status = nil
+            result.replace(_roda_handle_route do
+              r = @_request
+              opts[:class_level_routes].each do |request_meth, args, meth|
+                r.instance_variable_set(:@remaining_path, @_original_remaining_path)
+                r.public_send(request_meth, *args) do |*a|
+                  send(meth, *a)
+                end
+              end
+              nil
+            end)
+          end
+        end
+      end
+    end
+
+    register_plugin(:class_level_routing, ClassLevelRouting)
+  end
+end

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

@@ -0,0 +1,155 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The class_matchers plugin allows you do define custom regexps and
+    # conversion procs to use for specific classes.  For example, if you
+    # have multiple routes similar to:
+    #
+    #   r.on /(\d\d\d\d)-(\d\d)-(\d\d)/ do |y, m, d|
+    #     date = Date.new(y.to_i, m.to_i, d.to_i)
+    #     # ...
+    #   end
+    #
+    # You can register a Date class matcher for that regexp:
+    #
+    #   class_matcher(Date, /(\d\d\d\d)-(\d\d)-(\d\d)/) do |y, m, d|
+    #     Date.new(y.to_i, m.to_i, d.to_i)
+    #   end
+    #
+    # And then use the Date class as a matcher, and it will yield a Date object:
+    #
+    #   r.on Date do |date|
+    #     # ...
+    #   end
+    #
+    # This is useful to DRY up code if you are using the same type of pattern and
+    # type conversion in multiple places in your application. You can have the
+    # block return an array to yield multiple captures.
+    #
+    # If you have a segment match the passed regexp, but decide during block
+    # processing that you do not want to treat it as a match, you can have the
+    # block return nil or false.  This is useful if you want to make sure you
+    # are using valid data:
+    #
+    #   class_matcher(Date, /(\d\d\d\d)-(\d\d)-(\d\d)/) do |y, m, d|
+    #     y = y.to_i
+    #     m = m.to_i
+    #     d = d.to_i
+    #     Date.new(y, m, d) if Date.valid_date?(y, m, d)
+    #   end
+    #
+    # The second argument to class_matcher can be a class already registered
+    # as a class matcher. This can DRY up code that wants a conversion
+    # performed by an existing class matcher:
+    #
+    #   class_matcher Employee, Integer do |id|
+    #     Employee[id]
+    #   end
+    #
+    # With the above example, the Integer matcher performs the conversion to
+    # integer, so +id+ is yielded as an integer.  The block then looks up the
+    # employee with that id.  If there is no employee with that id, then
+    # the Employee matcher will not match.
+    #
+    # If using the symbol_matchers plugin, you can provide a recognized symbol
+    # matcher as the second argument to class_matcher, and it will work in
+    # a similar manner:
+    #
+    #   symbol_matcher(:employee_id, /E-(\d{6})/) do |employee_id|
+    #     employee_id.to_i
+    #   end
+    #   class_matcher Employee, :employee_id do |id|
+    #     Employee[id]
+    #   end
+    #
+    # Blocks passed to the class_matchers plugin are evaluated in route
+    # block context.
+    #
+    # When passing a regexp as a matcher, to class_matcher, you can provide a
+    # <tt>segment: true</tt> option to speed up the matching on Ruby 2.4+:
+    #
+    #   symbol_matcher(:employee_id, /E-(\d{6})/, segment: true) do |employee_id|
+    #     employee_id.to_i
+    #   end
+    #
+    # Use of <tt>segment: true</tt> requires that the regexp not match more than
+    # one segment (i.e. it cannot match +/+). Additionally, the entire segment will
+    # be captured, so any capture groups in the regexp will be ignored.
+    #
+    # This plugin does not work with the params_capturing plugin, as it does not
+    # offer the ability to associate block arguments with named keys.
+    module ClassMatchers
+      def self.load_dependencies(app)
+        app.plugin :_symbol_class_matchers
+      end
+
+      def self.configure(app)
+        app.opts[:class_matchers] ||= {
+          Integer=>[/(\d{1,100})/, /\A\/(\d{1,100})(?=\/|\z)/, :_convert_class_Integer].freeze,
+          String=>[/([^\/]+)/, nil, nil].freeze
+        }
+      end
+
+      module ClassMethods
+        # Set the matcher and block to use for the given class.
+        # The matcher can be a regexp, registered class matcher, or registered symbol
+        # matcher (if using the symbol_matchers plugin).
+        #
+        # If providing a regexp, the block given will be called with all regexp captures.
+        # If providing a registered class or symbol, the block will be called with the
+        # captures returned by the block for the registered class or symbol, or the regexp
+        # captures if no block was registered with the class or symbol. In either case,
+        # if a block is given, it should return an array with the captures to yield to
+        # the match block.
+        def class_matcher(klass, matcher, opts=OPTS, &block)
+          _symbol_class_matcher(Class, klass, matcher, block, opts) do |meth, (_, regexp, convert_meth, consume_meth)|
+            if regexp
+              if consume_meth == :_consume_single_segment
+                define_method(meth){_consume_single_segment(regexp, convert_meth)}
+              else
+                define_method(meth){consume(regexp, convert_meth)}
+              end
+            else
+              define_method(meth){_consume_segment(convert_meth)}
+            end
+          end
+        end
+
+        # Freeze the class_matchers hash when freezing the app.
+        def freeze
+          opts[:class_matchers].freeze
+          super
+        end
+      end
+
+      module RequestMethods
+        # Use faster approach for segment matching.  This is used for
+        # matchers based on the String class matcher, and avoids the
+        # use of regular expressions for scanning.
+        def _consume_segment(convert_meth)
+          rp = @remaining_path
+          if _match_class_String
+            if convert_meth
+              if captures = scope.send(convert_meth, @captures.pop)
+                if captures.is_a?(Array)
+                  @captures.concat(captures)
+                else
+                  @captures << captures
+                end
+              else
+                @remaining_path = rp
+                nil
+              end
+            else
+              true
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:class_matchers, ClassMatchers)
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The common_logger plugin adds common logger support to Roda
+    # applications, similar to Rack::CommonLogger, with the following
+    # differences:
+    #
+    # * Better performance
+    # * Doesn't include middleware timing
+    # * Doesn't proxy the body
+    # * Doesn't support different capitalization of the Content-Length response header
+    # * Logs to +$stderr+ instead of <tt>env['rack.errors']</tt> if explicit logger not passed
+    #
+    # Example:
+    #
+    #   plugin :common_logger
+    #   plugin :common_logger, $stdout
+    #   plugin :common_logger, Logger.new('filename')
+    #   plugin :common_logger, Logger.new('filename'), method: :debug
+    module CommonLogger
+      MUTATE_LINE = RUBY_VERSION < '2.3' || RUBY_VERSION >= '3'
+      private_constant :MUTATE_LINE
+
+      def self.configure(app, logger=nil, opts=OPTS)
+        app.opts[:common_logger] = logger || app.opts[:common_logger] || $stderr
+        app.opts[:common_logger_meth] = app.opts[:common_logger].method(opts.fetch(:method){logger.respond_to?(:write) ? :write : :<<})
+      end
+
+      if RUBY_VERSION >= '2.1'
+        # A timer object for calculating elapsed time.
+        def self.start_timer
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      else
+        # :nocov:
+        def self.start_timer # :nodoc:
+          Time.now
+        end
+        # :nocov:
+      end
+
+      module InstanceMethods
+        private
+
+        # Log request/response information in common log format to logger.
+        def _roda_after_90__common_logger(result)
+          return unless result && (status = result[0]) && (headers = result[1])
+
+          elapsed_time = if timer = @_request_timer
+            '%0.4f' % (CommonLogger.start_timer - timer)
+          else 
+            '-'
+          end
+
+          env = @_request.env
+
+          line = "#{env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-"} - #{env["REMOTE_USER"] || "-"} [#{Time.now.strftime("%d/%b/%Y:%H:%M:%S %z")}] \"#{env["REQUEST_METHOD"]} #{env["SCRIPT_NAME"]}#{env["PATH_INFO"]}#{"?#{env["QUERY_STRING"]}" if ((qs = env["QUERY_STRING"]) && !qs.empty?)} #{@_request.http_version}\" #{status} #{((length = headers[RodaResponseHeaders::CONTENT_LENGTH]) && (length unless length == '0')) || '-'} #{elapsed_time} "
+          if MUTATE_LINE
+            line.gsub!(/[^[:print:]]/){|c| sprintf("\\x%x", c.ord)}
+          # :nocov:
+          else
+            line = line.gsub(/[^[:print:]]/){|c| sprintf("\\x%x", c.ord)}
+          # :nocov:
+          end
+          line[-1] = "\n"
+          opts[:common_logger_meth].call(line)
+        end
+
+        # Create timer instance used for timing
+        def _roda_before_05__common_logger
+          @_request_timer = CommonLogger.start_timer
+        end
+      end
+    end
+
+    register_plugin(:common_logger, CommonLogger)
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+
+class Roda
+  module RodaPlugins
+    # The conditional_sessions plugin loads the sessions plugin.  However,
+    # it only allows sessions if the block passed to the plugin returns
+    # truthy.  The block is evaluated in request context. This is designed for
+    # use in applications that want to use sessions for some requests,
+    # and want to be sure that sessions are not used for other requests.
+    # For example, if you want to make sure that sessions are not used for
+    # requests with paths starting with /static, you could do:
+    #
+    #   plugin :conditional_sessions, secret: ENV["SECRET"] do
+    #     !path_info.start_with?('/static')
+    #   end
+    #
+    # The the request session, session_created_at, and session_updated_at methods
+    # raise a RodaError exception when sessions are not allowed.  The request
+    # persist_session and route scope clear_session methods do nothing when
+    # sessions are not allowed.
+    module ConditionalSessions
+      # Pass all options to the sessions block, and use the block to define
+      # a request method for whether sessions are allowed.
+      def self.load_dependencies(app, opts=OPTS, &block)
+        app.plugin :sessions, opts
+        app::RodaRequest.class_eval do
+          define_method(:use_sessions?, &block)
+          alias use_sessions? use_sessions?
+        end
+      end
+
+      module InstanceMethods
+        # Do nothing if not using sessions.
+        def clear_session
+          super if @_request.use_sessions?
+        end
+      end
+
+      module RequestMethods
+        # Raise RodaError if not using sessions.
+        def session
+          raise RodaError, "session called on request not using sessions" unless use_sessions?
+          super
+        end
+
+        # Raise RodaError if not using sessions.
+        def session_created_at
+          raise RodaError, "session_created_at called on request not using sessions" unless use_sessions?
+          super
+        end
+
+        # Raise RodaError if not using sessions.
+        def session_updated_at
+          raise RodaError, "session_updated_at called on request not using sessions" unless use_sessions?
+          super
+        end
+
+        # Do nothing if not using sessions.
+        def persist_session(headers, session)
+          super if use_sessions?
+        end
+      end
+    end
+
+    register_plugin(:conditional_sessions, ConditionalSessions)
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The content_for plugin is designed to be used with the
+    # render plugin, allowing you to store content inside one
+    # template, and retrieve that content inside a separate
+    # template.  Most commonly, this is so view templates
+    # can set content for the layout template to display outside
+    # of the normal content pane.
+    #
+    # In the template in which you want to store content, call
+    # content_for with a block:
+    #
+    #   <% content_for :foo do %>
+    #     Some content here.
+    #   <% end %>
+    #
+    # or:
+    #
+    #   <% content_for :foo do "Some content here." end %>
+    #
+    # You can also set the raw content as the second argument,
+    # instead of passing a block:
+    #
+    #   <% content_for :foo, "Some content" %>
+    #
+    # In the template in which you want to retrieve content,
+    # call content_for without the block or argument:
+    #
+    #   <%= content_for :foo %>
+    #
+    # Note that when storing content by calling content_for
+    # with a block and embedding template code, the return
+    # value of the block is used as the content (after being
+    # converted to a string).  This can cause issues in some
+    # cases, such as:
+    #
+    #   <% content_for :foo do %>
+    #     <% [1,2,3].each do |i| %>
+    #       Content <%= i %>
+    #     <% end %>
+    #   <% end %>
+    #
+    # In the above example, the return value of the block is
+    # <tt>[1,2,3]</tt>, as Array#each returns the receiver.
+    # If whitespace is not important, you can work around this by
+    # adding an empty line before the end of the content_for block.
+    #
+    # If content_for is used multiple times with the same key,
+    # by default, the last call will append previous calls.
+    # If you want to overwrite the previous content, pass the
+    # <tt>append: false</tt> option when loading the plugin:
+    #
+    #   plugin :content_for, append: false
+    module ContentFor
+      # Depend on the capture_erb plugin, since it uses capture_erb
+      # to capture the content.
+      def self.load_dependencies(app, _opts = OPTS)
+        app.plugin :capture_erb
+      end
+
+      # Configure whether to append or overwrite if content_for
+      # is called multiple times with the same key.
+      def self.configure(app, opts = OPTS)
+        app.opts[:append_content_for] = opts.fetch(:append, true)
+      end
+
+      module InstanceMethods
+        # If called with a block, store content enclosed by block
+        # under the given key.  If called without a block, retrieve
+        # stored content with the given key, or return nil if there
+        # is no content stored with that key.
+        def content_for(key, value=nil, &block)
+          append = opts[:append_content_for]
+
+          if block || value
+            if block
+              value = capture_erb(&block)
+            end
+
+            @_content_for ||= {}
+
+            if append
+              (@_content_for[key] ||= []) << value
+            else
+              @_content_for[key] = value
+            end
+          elsif @_content_for && (value = @_content_for[key])
+            if append
+              value = value.join
+            end
+
+            value
+          end
+        end
+      end
+    end
+
+    register_plugin(:content_for, ContentFor)
+  end
+end