zuora_connect_ui 0.8.1 → 0.8.2

data/vendor/ruby/2.6.0/gems/actionpack-6.0.0/lib/action_dispatch/routing/routes_proxy.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract_options"
+
+module ActionDispatch
+  module Routing
+    class RoutesProxy #:nodoc:
+      include ActionDispatch::Routing::UrlFor
+
+      attr_accessor :scope, :routes
+      alias :_routes :routes
+
+      def initialize(routes, scope, helpers, script_namer = nil)
+        @routes, @scope = routes, scope
+        @helpers = helpers
+        @script_namer = script_namer
+      end
+
+      def url_options
+        scope.send(:_with_routes, routes) do
+          scope.url_options
+        end
+      end
+
+    private
+      def respond_to_missing?(method, _)
+        super || @helpers.respond_to?(method)
+      end
+
+      def method_missing(method, *args)
+        if @helpers.respond_to?(method)
+          self.class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args)
+              options = args.extract_options!
+              options = url_options.merge((options || {}).symbolize_keys)
+
+              if @script_namer
+                options[:script_name] = merge_script_names(
+                  options[:script_name],
+                  @script_namer.call(options)
+                )
+              end
+
+              args << options
+              @helpers.#{method}(*args)
+            end
+          RUBY
+          public_send(method, *args)
+        else
+          super
+        end
+      end
+
+      # Keeps the part of the script name provided by the global
+      # context via ENV["SCRIPT_NAME"], which `mount` doesn't know
+      # about since it depends on the specific request, but use our
+      # script name resolver for the mount point dependent part.
+      def merge_script_names(previous_script_name, new_script_name)
+        return new_script_name unless previous_script_name
+
+        resolved_parts = new_script_name.count("/")
+        previous_parts = previous_script_name.count("/")
+        context_parts = previous_parts - resolved_parts + 1
+
+        (previous_script_name.split("/").slice(0, context_parts).join("/")) + new_script_name
+      end
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/actionpack-6.0.0/lib/action_dispatch/routing/url_for.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module Routing
+    # In <tt>config/routes.rb</tt> you define URL-to-controller mappings, but the reverse
+    # is also possible: a URL can be generated from one of your routing definitions.
+    # URL generation functionality is centralized in this module.
+    #
+    # See ActionDispatch::Routing for general information about routing and routes.rb.
+    #
+    # <b>Tip:</b> If you need to generate URLs from your models or some other place,
+    # then ActionController::UrlFor is what you're looking for. Read on for
+    # an introduction. In general, this module should not be included on its own,
+    # as it is usually included by url_helpers (as in Rails.application.routes.url_helpers).
+    #
+    # == URL generation from parameters
+    #
+    # As you may know, some functions, such as ActionController::Base#url_for
+    # and ActionView::Helpers::UrlHelper#link_to, can generate URLs given a set
+    # of parameters. For example, you've probably had the chance to write code
+    # like this in one of your views:
+    #
+    #   <%= link_to('Click here', controller: 'users',
+    #           action: 'new', message: 'Welcome!') %>
+    #   # => <a href="/users/new?message=Welcome%21">Click here</a>
+    #
+    # link_to, and all other functions that require URL generation functionality,
+    # actually use ActionController::UrlFor under the hood. And in particular,
+    # they use the ActionController::UrlFor#url_for method. One can generate
+    # the same path as the above example by using the following code:
+    #
+    #   include UrlFor
+    #   url_for(controller: 'users',
+    #           action: 'new',
+    #           message: 'Welcome!',
+    #           only_path: true)
+    #   # => "/users/new?message=Welcome%21"
+    #
+    # Notice the <tt>only_path: true</tt> part. This is because UrlFor has no
+    # information about the website hostname that your Rails app is serving. So if you
+    # want to include the hostname as well, then you must also pass the <tt>:host</tt>
+    # argument:
+    #
+    #   include UrlFor
+    #   url_for(controller: 'users',
+    #           action: 'new',
+    #           message: 'Welcome!',
+    #           host: 'www.example.com')
+    #   # => "http://www.example.com/users/new?message=Welcome%21"
+    #
+    # By default, all controllers and views have access to a special version of url_for,
+    # that already knows what the current hostname is. So if you use url_for in your
+    # controllers or your views, then you don't need to explicitly pass the <tt>:host</tt>
+    # argument.
+    #
+    # For convenience reasons, mailers provide a shortcut for ActionController::UrlFor#url_for.
+    # So within mailers, you only have to type +url_for+ instead of 'ActionController::UrlFor#url_for'
+    # in full. However, mailers don't have hostname information, and you still have to provide
+    # the +:host+ argument or set the default host that will be used in all mailers using the
+    # configuration option +config.action_mailer.default_url_options+. For more information on
+    # url_for in mailers read the ActionMailer#Base documentation.
+    #
+    #
+    # == URL generation for named routes
+    #
+    # UrlFor also allows one to access methods that have been auto-generated from
+    # named routes. For example, suppose that you have a 'users' resource in your
+    # <tt>config/routes.rb</tt>:
+    #
+    #   resources :users
+    #
+    # This generates, among other things, the method <tt>users_path</tt>. By default,
+    # this method is accessible from your controllers, views and mailers. If you need
+    # to access this auto-generated method from other places (such as a model), then
+    # you can do that by including Rails.application.routes.url_helpers in your class:
+    #
+    #   class User < ActiveRecord::Base
+    #     include Rails.application.routes.url_helpers
+    #
+    #     def base_uri
+    #       user_path(self)
+    #     end
+    #   end
+    #
+    #   User.find(1).base_uri # => "/users/1"
+    #
+    module UrlFor
+      extend ActiveSupport::Concern
+      include PolymorphicRoutes
+
+      included do
+        unless method_defined?(:default_url_options)
+          # Including in a class uses an inheritable hash. Modules get a plain hash.
+          if respond_to?(:class_attribute)
+            class_attribute :default_url_options
+          else
+            mattr_writer :default_url_options
+          end
+
+          self.default_url_options = {}
+        end
+
+        include(*_url_for_modules) if respond_to?(:_url_for_modules)
+      end
+
+      def initialize(*)
+        @_routes = nil
+        super
+      end
+
+      # Hook overridden in controller to add request information
+      # with +default_url_options+. Application logic should not
+      # go into url_options.
+      def url_options
+        default_url_options
+      end
+
+      # Generate a URL based on the options provided, default_url_options and the
+      # routes defined in routes.rb. The following options are supported:
+      #
+      # * <tt>:only_path</tt> - If true, the relative URL is returned. Defaults to +false+.
+      # * <tt>:protocol</tt> - The protocol to connect to. Defaults to 'http'.
+      # * <tt>:host</tt> - Specifies the host the link should be targeted at.
+      #   If <tt>:only_path</tt> is false, this option must be
+      #   provided either explicitly, or via +default_url_options+.
+      # * <tt>:subdomain</tt> - Specifies the subdomain of the link, using the +tld_length+
+      #   to split the subdomain from the host.
+      #   If false, removes all subdomains from the host part of the link.
+      # * <tt>:domain</tt> - Specifies the domain of the link, using the +tld_length+
+      #   to split the domain from the host.
+      # * <tt>:tld_length</tt> - Number of labels the TLD id composed of, only used if
+      #   <tt>:subdomain</tt> or <tt>:domain</tt> are supplied. Defaults to
+      #   <tt>ActionDispatch::Http::URL.tld_length</tt>, which in turn defaults to 1.
+      # * <tt>:port</tt> - Optionally specify the port to connect to.
+      # * <tt>:anchor</tt> - An anchor name to be appended to the path.
+      # * <tt>:params</tt> - The query parameters to be appended to the path.
+      # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2009/"
+      # * <tt>:script_name</tt> - Specifies application path relative to domain root. If provided, prepends application path.
+      #
+      # Any other key (<tt>:controller</tt>, <tt>:action</tt>, etc.) given to
+      # +url_for+ is forwarded to the Routes module.
+      #
+      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', port: '8080'
+      #    # => 'http://somehost.org:8080/tasks/testing'
+      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', anchor: 'ok', only_path: true
+      #    # => '/tasks/testing#ok'
+      #    url_for controller: 'tasks', action: 'testing', trailing_slash: true
+      #    # => 'http://somehost.org/tasks/testing/'
+      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', number: '33'
+      #    # => 'http://somehost.org/tasks/testing?number=33'
+      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', script_name: "/myapp"
+      #    # => 'http://somehost.org/myapp/tasks/testing'
+      #    url_for controller: 'tasks', action: 'testing', host: 'somehost.org', script_name: "/myapp", only_path: true
+      #    # => '/myapp/tasks/testing'
+      #
+      # Missing routes keys may be filled in from the current request's parameters
+      # (e.g. +:controller+, +:action+, +:id+ and any other parameters that are
+      # placed in the path). Given that the current action has been reached
+      # through <tt>GET /users/1</tt>:
+      #
+      #   url_for(only_path: true)                        # => '/users/1'
+      #   url_for(only_path: true, action: 'edit')        # => '/users/1/edit'
+      #   url_for(only_path: true, action: 'edit', id: 2) # => '/users/2/edit'
+      #
+      # Notice that no +:id+ parameter was provided to the first +url_for+ call
+      # and the helper used the one from the route's path. Any path parameter
+      # implicitly used by +url_for+ can always be overwritten like shown on the
+      # last +url_for+ calls.
+      def url_for(options = nil)
+        full_url_for(options)
+      end
+
+      def full_url_for(options = nil) # :nodoc:
+        case options
+        when nil
+          _routes.url_for(url_options.symbolize_keys)
+        when Hash, ActionController::Parameters
+          route_name = options.delete :use_route
+          merged_url_options = options.to_h.symbolize_keys.reverse_merge!(url_options)
+          _routes.url_for(merged_url_options, route_name)
+        when String
+          options
+        when Symbol
+          HelperMethodBuilder.url.handle_string_call self, options
+        when Array
+          components = options.dup
+          polymorphic_url(components, components.extract_options!)
+        when Class
+          HelperMethodBuilder.url.handle_class_call self, options
+        else
+          HelperMethodBuilder.url.handle_model_call self, options
+        end
+      end
+
+      # Allows calling direct or regular named route.
+      #
+      #   resources :buckets
+      #
+      #   direct :recordable do |recording|
+      #     route_for(:bucket, recording.bucket)
+      #   end
+      #
+      #   direct :threadable do |threadable|
+      #     route_for(:recordable, threadable.parent)
+      #   end
+      #
+      # This maintains the context of the original caller on
+      # whether to return a path or full URL, e.g:
+      #
+      #   threadable_path(threadable)  # => "/buckets/1"
+      #   threadable_url(threadable)   # => "http://example.com/buckets/1"
+      #
+      def route_for(name, *args)
+        public_send(:"#{name}_url", *args)
+      end
+
+      protected
+
+        def optimize_routes_generation?
+          _routes.optimize_routes_generation? && default_url_options.empty?
+        end
+
+      private
+
+        def _with_routes(routes) # :doc:
+          old_routes, @_routes = @_routes, routes
+          yield
+        ensure
+          @_routes = old_routes
+        end
+
+        def _routes_context # :doc:
+          self
+        end
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/actionpack-6.0.0/lib/action_dispatch/routing.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/filters"
+
+module ActionDispatch
+  # The routing module provides URL rewriting in native Ruby. It's a way to
+  # redirect incoming requests to controllers and actions. This replaces
+  # mod_rewrite rules. Best of all, Rails' \Routing works with any web server.
+  # Routes are defined in <tt>config/routes.rb</tt>.
+  #
+  # Think of creating routes as drawing a map for your requests. The map tells
+  # them where to go based on some predefined pattern:
+  #
+  #   Rails.application.routes.draw do
+  #     Pattern 1 tells some request to go to one place
+  #     Pattern 2 tell them to go to another
+  #     ...
+  #   end
+  #
+  # The following symbols are special:
+  #
+  #   :controller maps to your controller name
+  #   :action     maps to an action with your controllers
+  #
+  # Other names simply map to a parameter as in the case of <tt>:id</tt>.
+  #
+  # == Resources
+  #
+  # Resource routing allows you to quickly declare all of the common routes
+  # for a given resourceful controller. Instead of declaring separate routes
+  # for your +index+, +show+, +new+, +edit+, +create+, +update+ and +destroy+
+  # actions, a resourceful route declares them in a single line of code:
+  #
+  #  resources :photos
+  #
+  # Sometimes, you have a resource that clients always look up without
+  # referencing an ID. A common example, /profile always shows the profile of
+  # the currently logged in user. In this case, you can use a singular resource
+  # to map /profile (rather than /profile/:id) to the show action.
+  #
+  #  resource :profile
+  #
+  # It's common to have resources that are logically children of other
+  # resources:
+  #
+  #   resources :magazines do
+  #     resources :ads
+  #   end
+  #
+  # You may wish to organize groups of controllers under a namespace. Most
+  # commonly, you might group a number of administrative controllers under
+  # an +admin+ namespace. You would place these controllers under the
+  # <tt>app/controllers/admin</tt> directory, and you can group them together
+  # in your router:
+  #
+  #   namespace "admin" do
+  #     resources :posts, :comments
+  #   end
+  #
+  # Alternatively, you can add prefixes to your path without using a separate
+  # directory by using +scope+. +scope+ takes additional options which
+  # apply to all enclosed routes.
+  #
+  #   scope path: "/cpanel", as: 'admin' do
+  #     resources :posts, :comments
+  #   end
+  #
+  # For more, see <tt>Routing::Mapper::Resources#resources</tt>,
+  # <tt>Routing::Mapper::Scoping#namespace</tt>, and
+  # <tt>Routing::Mapper::Scoping#scope</tt>.
+  #
+  # == Non-resourceful routes
+  #
+  # For routes that don't fit the <tt>resources</tt> mold, you can use the HTTP helper
+  # methods <tt>get</tt>, <tt>post</tt>, <tt>patch</tt>, <tt>put</tt> and <tt>delete</tt>.
+  #
+  #   get 'post/:id', to: 'posts#show'
+  #   post 'post/:id', to: 'posts#create_comment'
+  #
+  # Now, if you POST to <tt>/posts/:id</tt>, it will route to the <tt>create_comment</tt> action. A GET on the same
+  # URL will route to the <tt>show</tt> action.
+  #
+  # If your route needs to respond to more than one HTTP method (or all methods) then using the
+  # <tt>:via</tt> option on <tt>match</tt> is preferable.
+  #
+  #   match 'post/:id', to: 'posts#show', via: [:get, :post]
+  #
+  # == Named routes
+  #
+  # Routes can be named by passing an <tt>:as</tt> option,
+  # allowing for easy reference within your source as +name_of_route_url+
+  # for the full URL and +name_of_route_path+ for the URI path.
+  #
+  # Example:
+  #
+  #   # In config/routes.rb
+  #   get '/login', to: 'accounts#login', as: 'login'
+  #
+  #   # With render, redirect_to, tests, etc.
+  #   redirect_to login_url
+  #
+  # Arguments can be passed as well.
+  #
+  #   redirect_to show_item_path(id: 25)
+  #
+  # Use <tt>root</tt> as a shorthand to name a route for the root path "/".
+  #
+  #   # In config/routes.rb
+  #   root to: 'blogs#index'
+  #
+  #   # would recognize http://www.example.com/ as
+  #   params = { controller: 'blogs', action: 'index' }
+  #
+  #   # and provide these named routes
+  #   root_url   # => 'http://www.example.com/'
+  #   root_path  # => '/'
+  #
+  # Note: when using +controller+, the route is simply named after the
+  # method you call on the block parameter rather than map.
+  #
+  #   # In config/routes.rb
+  #   controller :blog do
+  #     get 'blog/show',    to: :list
+  #     get 'blog/delete',  to: :delete
+  #     get 'blog/edit',    to: :edit
+  #   end
+  #
+  #   # provides named routes for show, delete, and edit
+  #   link_to @article.title, blog_show_path(id: @article.id)
+  #
+  # == Pretty URLs
+  #
+  # Routes can generate pretty URLs. For example:
+  #
+  #   get '/articles/:year/:month/:day', to: 'articles#find_by_id', constraints: {
+  #     year:       /\d{4}/,
+  #     month:      /\d{1,2}/,
+  #     day:        /\d{1,2}/
+  #   }
+  #
+  # Using the route above, the URL "http://localhost:3000/articles/2005/11/06"
+  # maps to
+  #
+  #   params = {year: '2005', month: '11', day: '06'}
+  #
+  # == Regular Expressions and parameters
+  # You can specify a regular expression to define a format for a parameter.
+  #
+  #   controller 'geocode' do
+  #     get 'geocode/:postalcode', to: :show, constraints: {
+  #       postalcode: /\d{5}(-\d{4})?/
+  #     }
+  #   end
+  #
+  # Constraints can include the 'ignorecase' and 'extended syntax' regular
+  # expression modifiers:
+  #
+  #   controller 'geocode' do
+  #     get 'geocode/:postalcode', to: :show, constraints: {
+  #       postalcode: /hx\d\d\s\d[a-z]{2}/i
+  #     }
+  #   end
+  #
+  #   controller 'geocode' do
+  #     get 'geocode/:postalcode', to: :show, constraints: {
+  #       postalcode: /# Postalcode format
+  #          \d{5} #Prefix
+  #          (-\d{4})? #Suffix
+  #          /x
+  #     }
+  #   end
+  #
+  # Using the multiline modifier will raise an +ArgumentError+.
+  # Encoding regular expression modifiers are silently ignored. The
+  # match will always use the default encoding or ASCII.
+  #
+  # == External redirects
+  #
+  # You can redirect any path to another path using the redirect helper in your router:
+  #
+  #   get "/stories", to: redirect("/posts")
+  #
+  # == Unicode character routes
+  #
+  # You can specify unicode character routes in your router:
+  #
+  #   get "こんにちは", to: "welcome#index"
+  #
+  # == Routing to Rack Applications
+  #
+  # Instead of a String, like <tt>posts#index</tt>, which corresponds to the
+  # index action in the PostsController, you can specify any Rack application
+  # as the endpoint for a matcher:
+  #
+  #   get "/application.js", to: Sprockets
+  #
+  # == Reloading routes
+  #
+  # You can reload routes if you feel you must:
+  #
+  #   Rails.application.reload_routes!
+  #
+  # This will clear all named routes and reload config/routes.rb if the file has been modified from
+  # last load. To absolutely force reloading, use <tt>reload!</tt>.
+  #
+  # == Testing Routes
+  #
+  # The two main methods for testing your routes:
+  #
+  # === +assert_routing+
+  #
+  #   def test_movie_route_properly_splits
+  #     opts = {controller: "plugin", action: "checkout", id: "2"}
+  #     assert_routing "plugin/checkout/2", opts
+  #   end
+  #
+  # +assert_routing+ lets you test whether or not the route properly resolves into options.
+  #
+  # === +assert_recognizes+
+  #
+  #   def test_route_has_options
+  #     opts = {controller: "plugin", action: "show", id: "12"}
+  #     assert_recognizes opts, "/plugins/show/12"
+  #   end
+  #
+  # Note the subtle difference between the two: +assert_routing+ tests that
+  # a URL fits options while +assert_recognizes+ tests that a URL
+  # breaks into parameters properly.
+  #
+  # In tests you can simply pass the URL or named route to +get+ or +post+.
+  #
+  #   def send_to_jail
+  #     get '/jail'
+  #     assert_response :success
+  #   end
+  #
+  #   def goes_to_login
+  #     get login_url
+  #     #...
+  #   end
+  #
+  # == View a list of all your routes
+  #
+  #   rails routes
+  #
+  # Target a specific controller with <tt>-c</tt>, or grep routes
+  # using <tt>-g</tt>. Useful in conjunction with <tt>--expanded</tt>
+  # which displays routes vertically.
+  module Routing
+    extend ActiveSupport::Autoload
+
+    autoload :Mapper
+    autoload :RouteSet
+    autoload :RoutesProxy
+    autoload :UrlFor
+    autoload :PolymorphicRoutes
+
+    SEPARATORS = %w( / . ? ) #:nodoc:
+    HTTP_METHODS = [:get, :head, :post, :patch, :put, :delete, :options] #:nodoc:
+  end
+end