ultra-max-sys 0.0.1

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

@@ -0,0 +1,285 @@
+# frozen-string-literal: true
+
+require 'stringio'
+require 'mail'
+
+class Roda
+  module RodaPlugins
+    # The mailer plugin allows your Roda application to send emails easily.
+    #
+    #   class Mailer < Roda
+    #     plugin :render
+    #     plugin :mailer
+    #
+    #     route do |r|
+    #       r.on "albums", Integer do |album_id|
+    #         @album = Album[album_id]
+    #
+    #         r.mail "added" do
+    #           from 'from@example.com'
+    #           to 'to@example.com'
+    #           cc 'cc@example.com'
+    #           bcc 'bcc@example.com'
+    #           subject 'Album Added'
+    #           add_file "path/to/album_added_img.jpg"
+    #           render(:albums_added_email) # body
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    # The default method for sending a mail is +sendmail+:
+    #
+    #   Mailer.sendmail("/albums/1/added")
+    #
+    # If you want to return the <tt>Mail::Message</tt> instance for further modification,
+    # you can just use the +mail+ method:
+    #
+    #   mail = Mailer.mail("/albums/1/added")
+    #   mail.from 'from2@example.com'
+    #   mail.deliver
+    #
+    # The mailer plugin uses the mail gem, so if you want to configure how
+    # email is sent, you can use <tt>Mail.defaults</tt> (see the mail gem documentation for
+    # more details):
+    #
+    #   Mail.defaults do
+    #     delivery_method :smtp, address: 'smtp.example.com', port: 587
+    #   end
+    #
+    # You can support multipart emails using +text_part+ and +html_part+:
+    #
+    #   r.mail "added" do
+    #     from 'from@example.com'
+    #     to 'to@example.com'
+    #     subject 'Album Added'
+    #     text_part render('album_added.txt')  # views/album_added.txt.erb
+    #     html_part render('album_added.html') # views/album_added.html.erb
+    #   end
+    #
+    # In addition to allowing you to use Roda's render plugin for rendering
+    # email bodies, you can use all of Roda's usual routing tree features
+    # to DRY up your code:
+    #
+    #   r.on "albums", Integer do |album_id|
+    #     @album = Album[album_id]
+    #     from 'from@example.com'
+    #     to 'to@example.com'
+    #
+    #     r.mail "added" do
+    #       subject 'Album Added'
+    #       render(:albums_added_email)
+    #     end
+    #
+    #     r.mail "deleted" do
+    #       subject 'Album Deleted'
+    #       render(:albums_deleted_email)
+    #     end
+    #   end
+    #
+    # When sending a mail via +mail+ or +sendmail+, a RodaError will be raised
+    # if the mail object does not have a body.  This is similar to the 404
+    # status that Roda uses by default for web requests that don't have
+    # a body. If you want to specifically send an email with an empty body, you
+    # can use the explicit empty string:
+    #
+    #   r.mail do
+    #     from 'from@example.com'
+    #     to 'to@example.com'
+    #     subject 'No Body Here'
+    #     ""
+    #   end
+    #
+    # If while preparing the email you figure out you don't want to send an
+    # email, call +no_mail!+:
+    #
+    #  r.mail 'welcome', Integer do |id| 
+    #    no_mail! unless user = User[id]
+    #    # ...
+    #  end
+    #
+    # You can pass arguments when calling +mail+ or +sendmail+, and they
+    # will be yielded as additional arguments to the appropriate +r.mail+ block:
+    # 
+    #  Mailer.sendmail('/welcome/1', 'foo@example.com')
+    #
+    #  r.mail 'welcome', Integer do |user_id, mail_from| 
+    #    from mail_from
+    #    to User[user_id].email
+    #    # ...
+    #  end
+    #
+    # By default, the mailer uses text/plain as the Content-Type for emails.
+    # You can override the default by specifying a :content_type option when
+    # loading the plugin:
+    #
+    #   plugin :mailer, content_type: 'text/html'
+    #
+    # For backwards compatibility reasons, the +r.mail+ method does not do
+    # a terminal match by default if provided arguments (unlike +r.get+ and
+    # +r.post+).  You can pass the :terminal option to make +r.mail+ enforce
+    # a terminal match if provided arguments.
+    #
+    # The mailer plugin does support being used inside a Roda application
+    # that is handling web requests, where the routing block for mails and
+    # web requests is shared.  However, it's recommended that you create a
+    # separate Roda application for emails. This can be a subclass of your main
+    # Roda application if you want your helper methods to automatically be
+    # available in your email views.
+    module Mailer
+      RESPONSE_INSTANCE_VARIABLES = [:@mail, :@mail_attachments].freeze
+
+      # Error raised when the using the mail class method, but the routing
+      # tree doesn't return the mail object. 
+      class Error < ::Roda::RodaError; end
+
+      # Set the options for the mailer.  Options:
+      # :content_type :: The default content type for emails (default: text/plain)
+      def self.configure(app, opts=OPTS)
+        app.opts[:mailer] = (app.opts[:mailer]||OPTS).merge(opts).freeze
+      end
+
+      module ClassMethods
+        # Return a Mail::Message instance for the email for the given request path
+        # and arguments.   Any arguments given are yielded to the appropriate +r.mail+
+        # block after any usual match block arguments. You can further manipulate the
+        #returned mail object before calling +deliver+ to send the mail.
+        def mail(path, *args)
+          mail = ::Mail.new
+          catch(:no_mail) do
+            unless mail.equal?(new("PATH_INFO"=>path, 'SCRIPT_NAME'=>'', "REQUEST_METHOD"=>"MAIL", 'rack.input'=>StringIO.new, 'roda.mail'=>mail, 'roda.mail_args'=>args)._roda_handle_main_route)
+              raise Error, "route did not return mail instance for #{path.inspect}, #{args.inspect}"
+            end
+            mail
+          end
+        end
+        # :nocov:
+        ruby2_keywords(:mail) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
+
+        # Calls +mail+ with given arguments and immediately sends the resulting mail.
+        def sendmail(*args)
+          if m = mail(*args)
+            m.deliver
+          end
+        end
+        # :nocov:
+        ruby2_keywords(:sendmail) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
+      end
+
+      module RequestMethods
+        # Similar to routing tree methods such as +get+ and +post+, this matches
+        # only if the request method is MAIL (only set when using the Roda class
+        # +mail+ or +sendmail+ methods) and the rest of the arguments match
+        # the request.  This yields any of the captures to the block, as well as
+        # any arguments passed to the +mail+ or +sendmail+ Roda class methods.
+        def mail(*args)
+          if @env["REQUEST_METHOD"] == "MAIL"
+            # RODA4: Make terminal match the default
+            send(roda_class.opts[:mailer][:terminal] ? :_verb : :if_match, args) do |*vs|
+              yield(*(vs + @env['roda.mail_args']))
+            end
+          end
+        end
+      end
+
+      module ResponseMethods
+        # The mail object related to the current request.
+        attr_accessor :mail
+
+        # If the related request was an email request, add any response headers
+        # to the email, as well as adding the response body to the email.
+        # Return the email unless no body was set for it, which would indicate
+        # that the routing tree did not handle the request.
+        def finish
+          if m = mail
+            header_content_type = @headers.delete(RodaResponseHeaders::CONTENT_TYPE)
+            m.headers(@headers)
+            m.body(@body.join) unless @body.empty?
+            mail_attachments.each do |a, block|
+              m.add_file(*a)
+              block.call if block
+            end
+
+            if content_type = header_content_type || roda_class.opts[:mailer][:content_type]
+              if mail.multipart?
+                if /multipart\/mixed/ =~ mail.content_type &&
+                   mail.parts.length >= 2 &&
+                   (part = mail.parts.find{|p| !p.attachment && (p.encoded; /text\/plain/ =~ p.content_type)})
+                  part.content_type = content_type
+                end
+              else
+                mail.content_type = content_type
+              end
+            end
+
+            unless m.body.to_s.empty? && m.parts.empty? && @body.empty?
+              m
+            end
+          else
+            super
+          end
+        end
+
+        # The attachments related to the current mail.
+        def mail_attachments
+          @mail_attachments ||= []
+        end
+      end
+
+      module InstanceMethods
+        # Add delegates for common email methods.
+        [:from, :to, :cc, :bcc, :subject].each do |meth|
+          define_method(meth) do |*args|
+            env['roda.mail'].public_send(meth, *args)
+            nil
+          end
+        end
+        [:text_part, :html_part].each do |meth|
+          define_method(meth) do |*args|
+            _mail_part(meth, *args)
+          end
+        end
+
+        # If this is an email request, set the mail object in the response, as well
+        # as the default content_type for the email.
+        def initialize(env)
+          super
+          if mail = env['roda.mail']
+            res = @_response
+            res.mail = mail
+            res.headers.delete(RodaResponseHeaders::CONTENT_TYPE)
+          end
+        end
+
+        # Delay adding a file to the message until after the message body has been set.
+        # If a block is given, the block is called after the file has been added, and you
+        # can access the attachment via <tt>response.mail_attachments.last</tt>.
+        def add_file(*a, &block)
+          response.mail_attachments << [a, block]
+          nil
+        end
+
+        # Signal that no mail should be sent for this request.
+        def no_mail!
+          throw :no_mail
+        end
+
+        private
+
+        # Set the text_part or html_part (depending on the method) in the related email,
+        # using the given body and optional headers.
+        def _mail_part(meth, body, headers=nil)
+          env['roda.mail'].public_send(meth) do
+            body(body)
+            headers(headers) if headers
+          end
+          nil
+        end
+      end
+    end
+
+    register_plugin(:mailer, Mailer)
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The map_matcher plugin allows you to provide a string-keyed
+    # hash during route matching, and match any of the keys in the hash
+    # as the next segment in the request path, yielding the corresponding
+    # value in the hash:
+    #
+    #   class App < Roda
+    #     plugin :map_matcher
+    #
+    #     map = { "foo" => "bar", "baz" => "quux" }.freeze
+    #
+    #     route do
+    #       r.get map: map do |v|
+    #         v
+    #         # GET /foo => bar
+    #         # GET /baz => quux
+    #       end
+    #     end
+    #   end
+    module MapMatcher
+      module RequestMethods
+        private
+
+        # Match only if the next segment in the path is one of the keys
+        # in the hash, and yield the value of the hash.
+        def match_map(hash)
+          rp = @remaining_path
+          if key = _match_class_String
+            if value = hash[@captures[-1]]
+              @captures[-1] = value
+              true
+            else
+              @remaining_path = rp
+              @captures.pop
+              false
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:map_matcher, MapMatcher)
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The match_affix plugin allows changing the default prefix and suffix used for
+    # match patterns.  Roda's default behavior for a match pattern like <tt>"albums"</tt>
+    # is to use the pattern <tt>/\A\/(?:albums)(?=\/|\z)/</tt>.  This prefixes the pattern
+    # with +/+ and suffixes it with <tt>(?=\/|\z)</tt>.  With the match_affix plugin, you
+    # can change the prefix and suffix to use.  So if you want to be explicit and require
+    # a leading +/+ in patterns, you can set the prefix to <tt>""</tt>.  If you want to
+    # consume a trailing slash instead of leaving it, you can set the suffix to <tt>(\/|\z)</tt>.
+    #
+    # You set the prefix and suffix to use by passing arguments when loading the plugin:
+    #
+    #   plugin :match_affix, ""
+    #
+    # will load the plugin and use an empty prefix (instead of a slash).
+    #
+    #   plugin :match_affix, "", /(\/|\z)/
+    #
+    # will use an empty prefix and change the suffix to consume a trailing slash.
+    #
+    #  plugin :match_affix, nil, /(?:\/\z|(?=\/|\z))/
+    #
+    # will not modify the prefix and will change the suffix so that it consumes a trailing slash
+    # at the end of the path only.
+    #
+    # This plugin automatically loads the placeholder_string_matchers plugin.
+    module MatchAffix
+      def self.load_dependencies(app, _prefix, _suffix=nil)
+        app.plugin :placeholder_string_matchers
+      end
+
+      # Set the default prefix and suffix to use in match patterns, if a non-nil value
+      # is given.
+      def self.configure(app, prefix, suffix=nil)
+        app.opts[:match_prefix] = prefix if prefix
+        app.opts[:match_suffix] = suffix if suffix
+      end
+      
+      module RequestClassMethods
+        private
+
+        # Use the match prefix and suffix provided when loading the plugin, or fallback
+        # to Roda's default prefix/suffix if one was not provided.
+        def consume_pattern(pattern)
+          /\A#{roda_class.opts[:match_prefix] || "/"}(?:#{pattern})#{roda_class.opts[:match_suffix] || "(?=\/|\z)"}/
+        end
+      end
+
+      module RequestMethods
+        private
+
+        # Use regexps for all string matches, so that the prefix and suffix matches work.
+        def _match_string(str)
+          consume(self.class.cached_matcher(str){Regexp.escape(str).gsub(/:(\w+)/){|m| _match_symbol_regexp($1)}})
+        end
+      end
+    end
+
+    register_plugin(:match_affix, MatchAffix)
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The match_hook plugin adds hooks that are called upon a successful match
+    # by any of the matchers.  The hooks do not take any arguments.  If you would
+    # like hooks that pass the arguments/matchers and values yielded to the route block,
+    # use the match_hook_args plugin. This uses the match_hook_args plugin internally,
+    # but doesn't pass the matchers and values yielded.
+    #
+    #   plugin :match_hook
+    #
+    #   match_hook do
+    #     logger.debug("#{request.matched_path} matched. #{request.remaining_path} remaining.")
+    #   end
+    module MatchHook
+      def self.load_dependencies(app)
+        app.plugin :match_hook_args
+      end
+
+      module ClassMethods
+        # Add a match hook.
+        def match_hook(&block)
+          meth = define_roda_method("match_hook", 0, &block)
+          add_match_hook{|_,_| send(meth)}
+          nil
+        end
+      end
+    end
+
+    register_plugin :match_hook, MatchHook
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The match_hook_args plugin adds hooks that are called upon a successful match
+    # by any of the matchers. It is similar to the match_hook plugin, but it allows
+    # for passing the matchers and block arguments for each match method.
+    #
+    #   plugin :match_hook_args
+    #
+    #   add_match_hook do |matchers, block_args|
+    #     logger.debug("matchers: #{matchers.inspect}. #{block_args.inspect} yielded.")
+    #   end
+    #
+    #   # Term is an implicit matcher used for terminating matches, and
+    #   # will be included in the array of matchers yielded to the match hook 
+    #   # if a terminating match is used.
+    #   term = self.class::RodaRequest::TERM
+    #
+    #   route do |r|
+    #     r.root do
+    #       # for a request for /
+    #       # matchers: nil, block_args: nil
+    #     end
+    #
+    #     r.on 'a', ['b', 'c'], Integer do |segment, id|
+    #       # for a request for /a/b/1
+    #       # matchers: ["a", ["b", "c"], Integer], block_args: ["b", 1]
+    #     end
+    #
+    #     r.get 'd' do
+    #       # for a request for /d
+    #       # matchers: ["d", term], block_args: []
+    #     end
+    #   end
+    module MatchHookArgs
+      def self.configure(app)
+        app.opts[:match_hook_args] ||= []
+      end
+
+      module ClassMethods
+        # Freeze the array of hook methods when freezing the app
+        def freeze
+          opts[:match_hook_args].freeze
+          super
+        end
+
+        # Add a match hook that will be called with matchers and block args.
+        def add_match_hook(&block)
+          opts[:match_hook_args] << define_roda_method("match_hook_args", :any, &block)
+
+          if opts[:match_hook_args].length == 1
+            class_eval("alias _match_hook_args #{opts[:match_hook_args].first}", __FILE__, __LINE__)
+          else
+            class_eval("def _match_hook_args(v, a); #{opts[:match_hook_args].map{|m| "#{m}(v, a)"}.join(';')} end", __FILE__, __LINE__)
+          end
+
+          public :_match_hook_args
+
+          nil
+        end
+      end
+
+      module InstanceMethods
+        # Default empty method if no match hooks are defined.
+        def _match_hook_args(matchers, block_args)
+        end
+      end
+
+      module RequestMethods
+        private
+
+        # Call the match hook with matchers and block args if yielding to the block before yielding to the block.
+        def if_match(v)
+          super do |*a|
+            scope._match_hook_args(v, a)
+            yield(*a)
+          end
+        end
+
+        # Call the match hook with nil matchers and blocks before yielding to the block
+        def always
+          scope._match_hook_args(nil, nil)
+          super
+        end
+      end
+    end
+
+    register_plugin :match_hook_args, MatchHookArgs
+  end
+end
+