zuora_connect_ui 0.8.1 → 0.8.2

data/vendor/ruby/2.6.0/gems/actionpack-6.0.0/lib/abstract_controller/base.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "abstract_controller/error"
+require "active_support/configurable"
+require "active_support/descendants_tracker"
+require "active_support/core_ext/module/anonymous"
+require "active_support/core_ext/module/attr_internal"
+
+module AbstractController
+  # Raised when a non-existing controller action is triggered.
+  class ActionNotFound < StandardError
+  end
+
+  # AbstractController::Base is a low-level API. Nobody should be
+  # using it directly, and subclasses (like ActionController::Base) are
+  # expected to provide their own +render+ method, since rendering means
+  # different things depending on the context.
+  class Base
+    ##
+    # Returns the body of the HTTP response sent by the controller.
+    attr_internal :response_body
+
+    ##
+    # Returns the name of the action this controller is processing.
+    attr_internal :action_name
+
+    ##
+    # Returns the formats that can be processed by the controller.
+    attr_internal :formats
+
+    include ActiveSupport::Configurable
+    extend ActiveSupport::DescendantsTracker
+
+    class << self
+      attr_reader :abstract
+      alias_method :abstract?, :abstract
+
+      # Define a controller as abstract. See internal_methods for more
+      # details.
+      def abstract!
+        @abstract = true
+      end
+
+      def inherited(klass) # :nodoc:
+        # Define the abstract ivar on subclasses so that we don't get
+        # uninitialized ivar warnings
+        unless klass.instance_variable_defined?(:@abstract)
+          klass.instance_variable_set(:@abstract, false)
+        end
+        super
+      end
+
+      # A list of all internal methods for a controller. This finds the first
+      # abstract superclass of a controller, and gets a list of all public
+      # instance methods on that abstract class. Public instance methods of
+      # a controller would normally be considered action methods, so methods
+      # declared on abstract classes are being removed.
+      # (<tt>ActionController::Metal</tt> and ActionController::Base are defined as abstract)
+      def internal_methods
+        controller = self
+
+        controller = controller.superclass until controller.abstract?
+        controller.public_instance_methods(true)
+      end
+
+      # A list of method names that should be considered actions. This
+      # includes all public instance methods on a controller, less
+      # any internal methods (see internal_methods), adding back in
+      # any methods that are internal, but still exist on the class
+      # itself.
+      #
+      # ==== Returns
+      # * <tt>Set</tt> - A set of all methods that should be considered actions.
+      def action_methods
+        @action_methods ||= begin
+          # All public instance methods of this class, including ancestors
+          methods = (public_instance_methods(true) -
+            # Except for public instance methods of Base and its ancestors
+            internal_methods +
+            # Be sure to include shadowed public instance methods of this class
+            public_instance_methods(false))
+
+          methods.map!(&:to_s)
+
+          methods.to_set
+        end
+      end
+
+      # action_methods are cached and there is sometimes a need to refresh
+      # them. ::clear_action_methods! allows you to do that, so next time
+      # you run action_methods, they will be recalculated.
+      def clear_action_methods!
+        @action_methods = nil
+      end
+
+      # Returns the full controller name, underscored, without the ending Controller.
+      #
+      #   class MyApp::MyPostsController < AbstractController::Base
+      #
+      #   end
+      #
+      #   MyApp::MyPostsController.controller_path # => "my_app/my_posts"
+      #
+      # ==== Returns
+      # * <tt>String</tt>
+      def controller_path
+        @controller_path ||= name.sub(/Controller$/, "").underscore unless anonymous?
+      end
+
+      # Refresh the cached action_methods when a new action_method is added.
+      def method_added(name)
+        super
+        clear_action_methods!
+      end
+    end
+
+    abstract!
+
+    # Calls the action going through the entire action dispatch stack.
+    #
+    # The actual method that is called is determined by calling
+    # #method_for_action. If no method can handle the action, then an
+    # AbstractController::ActionNotFound error is raised.
+    #
+    # ==== Returns
+    # * <tt>self</tt>
+    def process(action, *args)
+      @_action_name = action.to_s
+
+      unless action_name = _find_action_name(@_action_name)
+        raise ActionNotFound, "The action '#{action}' could not be found for #{self.class.name}"
+      end
+
+      @_response_body = nil
+
+      process_action(action_name, *args)
+    end
+
+    # Delegates to the class' ::controller_path
+    def controller_path
+      self.class.controller_path
+    end
+
+    # Delegates to the class' ::action_methods
+    def action_methods
+      self.class.action_methods
+    end
+
+    # Returns true if a method for the action is available and
+    # can be dispatched, false otherwise.
+    #
+    # Notice that <tt>action_methods.include?("foo")</tt> may return
+    # false and <tt>available_action?("foo")</tt> returns true because
+    # this method considers actions that are also available
+    # through other means, for example, implicit render ones.
+    #
+    # ==== Parameters
+    # * <tt>action_name</tt> - The name of an action to be tested
+    def available_action?(action_name)
+      _find_action_name(action_name)
+    end
+
+    # Tests if a response body is set. Used to determine if the
+    # +process_action+ callback needs to be terminated in
+    # +AbstractController::Callbacks+.
+    def performed?
+      response_body
+    end
+
+    # Returns true if the given controller is capable of rendering
+    # a path. A subclass of +AbstractController::Base+
+    # may return false. An Email controller for example does not
+    # support paths, only full URLs.
+    def self.supports_path?
+      true
+    end
+
+    private
+
+      # Returns true if the name can be considered an action because
+      # it has a method defined in the controller.
+      #
+      # ==== Parameters
+      # * <tt>name</tt> - The name of an action to be tested
+      def action_method?(name)
+        self.class.action_methods.include?(name)
+      end
+
+      # Call the action. Override this in a subclass to modify the
+      # behavior around processing an action. This, and not #process,
+      # is the intended way to override action dispatching.
+      #
+      # Notice that the first argument is the method to be dispatched
+      # which is *not* necessarily the same as the action name.
+      def process_action(method_name, *args)
+        send_action(method_name, *args)
+      end
+
+      # Actually call the method associated with the action. Override
+      # this method if you wish to change how action methods are called,
+      # not to add additional behavior around it. For example, you would
+      # override #send_action if you want to inject arguments into the
+      # method.
+      alias send_action send
+
+      # If the action name was not found, but a method called "action_missing"
+      # was found, #method_for_action will return "_handle_action_missing".
+      # This method calls #action_missing with the current action name.
+      def _handle_action_missing(*args)
+        action_missing(@_action_name, *args)
+      end
+
+      # Takes an action name and returns the name of the method that will
+      # handle the action.
+      #
+      # It checks if the action name is valid and returns false otherwise.
+      #
+      # See method_for_action for more information.
+      #
+      # ==== Parameters
+      # * <tt>action_name</tt> - An action name to find a method name for
+      #
+      # ==== Returns
+      # * <tt>string</tt> - The name of the method that handles the action
+      # * false           - No valid method name could be found.
+      # Raise +AbstractController::ActionNotFound+.
+      def _find_action_name(action_name)
+        _valid_action_name?(action_name) && method_for_action(action_name)
+      end
+
+      # Takes an action name and returns the name of the method that will
+      # handle the action. In normal cases, this method returns the same
+      # name as it receives. By default, if #method_for_action receives
+      # a name that is not an action, it will look for an #action_missing
+      # method and return "_handle_action_missing" if one is found.
+      #
+      # Subclasses may override this method to add additional conditions
+      # that should be considered an action. For instance, an HTTP controller
+      # with a template matching the action name is considered to exist.
+      #
+      # If you override this method to handle additional cases, you may
+      # also provide a method (like +_handle_method_missing+) to handle
+      # the case.
+      #
+      # If none of these conditions are true, and +method_for_action+
+      # returns +nil+, an +AbstractController::ActionNotFound+ exception will be raised.
+      #
+      # ==== Parameters
+      # * <tt>action_name</tt> - An action name to find a method name for
+      #
+      # ==== Returns
+      # * <tt>string</tt> - The name of the method that handles the action
+      # * <tt>nil</tt>    - No method name could be found.
+      def method_for_action(action_name)
+        if action_method?(action_name)
+          action_name
+        elsif respond_to?(:action_missing, true)
+          "_handle_action_missing"
+        end
+      end
+
+      # Checks if the action name is valid and returns false otherwise.
+      def _valid_action_name?(action_name)
+        !action_name.to_s.include? File::SEPARATOR
+      end
+  end
+end

data/vendor/ruby/2.6.0/gems/actionpack-6.0.0/lib/abstract_controller/caching/fragments.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module AbstractController
+  module Caching
+    # Fragment caching is used for caching various blocks within
+    # views without caching the entire action as a whole. This is
+    # useful when certain elements of an action change frequently or
+    # depend on complicated state while other parts rarely change or
+    # can be shared amongst multiple parties. The caching is done using
+    # the +cache+ helper available in the Action View. See
+    # ActionView::Helpers::CacheHelper for more information.
+    #
+    # While it's strongly recommended that you use key-based cache
+    # expiration (see links in CacheHelper for more information),
+    # it is also possible to manually expire caches. For example:
+    #
+    #   expire_fragment('name_of_cache')
+    module Fragments
+      extend ActiveSupport::Concern
+
+      included do
+        if respond_to?(:class_attribute)
+          class_attribute :fragment_cache_keys
+        else
+          mattr_writer :fragment_cache_keys
+        end
+
+        self.fragment_cache_keys = []
+
+        if respond_to?(:helper_method)
+          helper_method :combined_fragment_cache_key
+        end
+      end
+
+      module ClassMethods
+        # Allows you to specify controller-wide key prefixes for
+        # cache fragments. Pass either a constant +value+, or a block
+        # which computes a value each time a cache key is generated.
+        #
+        # For example, you may want to prefix all fragment cache keys
+        # with a global version identifier, so you can easily
+        # invalidate all caches.
+        #
+        #   class ApplicationController
+        #     fragment_cache_key "v1"
+        #   end
+        #
+        # When it's time to invalidate all fragments, simply change
+        # the string constant. Or, progressively roll out the cache
+        # invalidation using a computed value:
+        #
+        #   class ApplicationController
+        #     fragment_cache_key do
+        #       @account.id.odd? ? "v1" : "v2"
+        #     end
+        #   end
+        def fragment_cache_key(value = nil, &key)
+          self.fragment_cache_keys += [key || -> { value }]
+        end
+      end
+
+      # Given a key (as described in +expire_fragment+), returns
+      # a key array suitable for use in reading, writing, or expiring a
+      # cached fragment. All keys begin with <tt>:views</tt>,
+      # followed by <tt>ENV["RAILS_CACHE_ID"]</tt> or <tt>ENV["RAILS_APP_VERSION"]</tt> if set,
+      # followed by any controller-wide key prefix values, ending
+      # with the specified +key+ value.
+      def combined_fragment_cache_key(key)
+        head = self.class.fragment_cache_keys.map { |k| instance_exec(&k) }
+        tail = key.is_a?(Hash) ? url_for(key).split("://").last : key
+
+        cache_key = [:views, ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"], head, tail]
+        cache_key.flatten!(1)
+        cache_key.compact!
+        cache_key
+      end
+
+      # Writes +content+ to the location signified by
+      # +key+ (see +expire_fragment+ for acceptable formats).
+      def write_fragment(key, content, options = nil)
+        return content unless cache_configured?
+
+        key = combined_fragment_cache_key(key)
+        instrument_fragment_cache :write_fragment, key do
+          content = content.to_str
+          cache_store.write(key, content, options)
+        end
+        content
+      end
+
+      # Reads a cached fragment from the location signified by +key+
+      # (see +expire_fragment+ for acceptable formats).
+      def read_fragment(key, options = nil)
+        return unless cache_configured?
+
+        key = combined_fragment_cache_key(key)
+        instrument_fragment_cache :read_fragment, key do
+          result = cache_store.read(key, options)
+          result.respond_to?(:html_safe) ? result.html_safe : result
+        end
+      end
+
+      # Check if a cached fragment from the location signified by
+      # +key+ exists (see +expire_fragment+ for acceptable formats).
+      def fragment_exist?(key, options = nil)
+        return unless cache_configured?
+        key = combined_fragment_cache_key(key)
+
+        instrument_fragment_cache :exist_fragment?, key do
+          cache_store.exist?(key, options)
+        end
+      end
+
+      # Removes fragments from the cache.
+      #
+      # +key+ can take one of three forms:
+      #
+      # * String - This would normally take the form of a path, like
+      #   <tt>pages/45/notes</tt>.
+      # * Hash - Treated as an implicit call to +url_for+, like
+      #   <tt>{ controller: 'pages', action: 'notes', id: 45}</tt>
+      # * Regexp - Will remove any fragment that matches, so
+      #   <tt>%r{pages/\d*/notes}</tt> might remove all notes. Make sure you
+      #   don't use anchors in the regex (<tt>^</tt> or <tt>$</tt>) because
+      #   the actual filename matched looks like
+      #   <tt>./cache/filename/path.cache</tt>. Note: Regexp expiration is
+      #   only supported on caches that can iterate over all keys (unlike
+      #   memcached).
+      #
+      # +options+ is passed through to the cache store's +delete+
+      # method (or <tt>delete_matched</tt>, for Regexp keys).
+      def expire_fragment(key, options = nil)
+        return unless cache_configured?
+        key = combined_fragment_cache_key(key) unless key.is_a?(Regexp)
+
+        instrument_fragment_cache :expire_fragment, key do
+          if key.is_a?(Regexp)
+            cache_store.delete_matched(key, options)
+          else
+            cache_store.delete(key, options)
+          end
+        end
+      end
+
+      def instrument_fragment_cache(name, key) # :nodoc:
+        ActiveSupport::Notifications.instrument("#{name}.#{instrument_name}", instrument_payload(key)) { yield }
+      end
+    end
+  end
+end

data/vendor/ruby/2.6.0/gems/actionpack-6.0.0/lib/abstract_controller/caching.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module AbstractController
+  module Caching
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Fragments
+    end
+
+    module ConfigMethods
+      def cache_store
+        config.cache_store
+      end
+
+      def cache_store=(store)
+        config.cache_store = ActiveSupport::Cache.lookup_store(store)
+      end
+
+      private
+        def cache_configured?
+          perform_caching && cache_store
+        end
+    end
+
+    include ConfigMethods
+    include AbstractController::Caching::Fragments
+
+    included do
+      extend ConfigMethods
+
+      config_accessor :default_static_extension
+      self.default_static_extension ||= ".html"
+
+      config_accessor :perform_caching
+      self.perform_caching = true if perform_caching.nil?
+
+      config_accessor :enable_fragment_cache_logging
+      self.enable_fragment_cache_logging = false
+
+      class_attribute :_view_cache_dependencies, default: []
+      helper_method :view_cache_dependencies if respond_to?(:helper_method)
+    end
+
+    module ClassMethods
+      def view_cache_dependency(&dependency)
+        self._view_cache_dependencies += [dependency]
+      end
+    end
+
+    def view_cache_dependencies
+      self.class._view_cache_dependencies.map { |dep| instance_exec(&dep) }.compact
+    end
+
+    private
+      # Convenience accessor.
+      def cache(key, options = {}, &block) # :doc:
+        if cache_configured?
+          cache_store.fetch(ActiveSupport::Cache.expand_cache_key(key, :controller), options, &block)
+        else
+          yield
+        end
+      end
+  end
+end