jets 1.9.7 → 1.9.8

data/vendor/rails/actionpack/lib/abstract_controller/caching.rb

@@ -1,66 +0,0 @@
-# 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

data/vendor/rails/actionpack/lib/abstract_controller/caching/fragments.rb

@@ -1,166 +0,0 @@
-# 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 :fragment_cache_key
-          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 suitable for use in reading, writing, or expiring a
-      # cached fragment. All keys begin with <tt>views/</tt>,
-      # followed by any controller-wide key prefix values, ending
-      # with the specified +key+ value. The key is expanded using
-      # ActiveSupport::Cache.expand_cache_key.
-      def fragment_cache_key(key)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          Calling fragment_cache_key directly is deprecated and will be removed in Rails 6.0.
-          All fragment accessors now use the combined_fragment_cache_key method that retains the key as an array,
-          such that the caching stores can interrogate the parts for cache versions used in
-          recyclable cache keys.
-        MSG
-
-        head = self.class.fragment_cache_keys.map { |k| instance_exec(&k) }
-        tail = key.is_a?(Hash) ? url_for(key).split("://").last : key
-        ActiveSupport::Cache.expand_cache_key([*head, *tail], :views)
-      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 ENV["RAILS_CACHE_ID"] or ENV["RAILS_APP_VERSION"] 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
-        [ :views, (ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]), *head, *tail ].compact
-      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/rails/actionpack/lib/abstract_controller/callbacks.rb

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-module AbstractController
-  # = Abstract Controller Callbacks
-  #
-  # Abstract Controller provides hooks during the life cycle of a controller action.
-  # Callbacks allow you to trigger logic during this cycle. Available callbacks are:
-  #
-  # * <tt>after_action</tt>
-  # * <tt>append_after_action</tt>
-  # * <tt>append_around_action</tt>
-  # * <tt>append_before_action</tt>
-  # * <tt>around_action</tt>
-  # * <tt>before_action</tt>
-  # * <tt>prepend_after_action</tt>
-  # * <tt>prepend_around_action</tt>
-  # * <tt>prepend_before_action</tt>
-  # * <tt>skip_after_action</tt>
-  # * <tt>skip_around_action</tt>
-  # * <tt>skip_before_action</tt>
-  #
-  # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
-  #
-  module Callbacks
-    extend ActiveSupport::Concern
-
-    # Uses ActiveSupport::Callbacks as the base functionality. For
-    # more details on the whole callback system, read the documentation
-    # for ActiveSupport::Callbacks.
-    include ActiveSupport::Callbacks
-
-    included do
-      define_callbacks :process_action,
-                       terminator: ->(controller, result_lambda) { result_lambda.call; controller.performed? },
-                       skip_after_callbacks_if_terminated: true
-    end
-
-    # Override <tt>AbstractController::Base#process_action</tt> to run the
-    # <tt>process_action</tt> callbacks around the normal behavior.
-    def process_action(*args)
-      run_callbacks(:process_action) do
-        super
-      end
-    end
-
-    module ClassMethods
-      # If +:only+ or +:except+ are used, convert the options into the
-      # +:if+ and +:unless+ options of ActiveSupport::Callbacks.
-      #
-      # The basic idea is that <tt>:only => :index</tt> gets converted to
-      # <tt>:if => proc {|c| c.action_name == "index" }</tt>.
-      #
-      # Note that <tt>:only</tt> has priority over <tt>:if</tt> in case they
-      # are used together.
-      #
-      #   only: :index, if: -> { true } # the :if option will be ignored.
-      #
-      # Note that <tt>:if</tt> has priority over <tt>:except</tt> in case they
-      # are used together.
-      #
-      #   except: :index, if: -> { true } # the :except option will be ignored.
-      #
-      # ==== Options
-      # * <tt>only</tt>   - The callback should be run only for this action.
-      # * <tt>except</tt>  - The callback should be run for all actions except this action.
-      def _normalize_callback_options(options)
-        _normalize_callback_option(options, :only, :if)
-        _normalize_callback_option(options, :except, :unless)
-      end
-
-      def _normalize_callback_option(options, from, to) # :nodoc:
-        if from = options[from]
-          _from = Array(from).map(&:to_s).to_set
-          from = proc { |c| _from.include? c.action_name }
-          options[to] = Array(options[to]).unshift(from)
-        end
-      end
-
-      # Take callback names and an optional callback proc, normalize them,
-      # then call the block with each callback. This allows us to abstract
-      # the normalization across several methods that use it.
-      #
-      # ==== Parameters
-      # * <tt>callbacks</tt> - An array of callbacks, with an optional
-      #   options hash as the last parameter.
-      # * <tt>block</tt>    - A proc that should be added to the callbacks.
-      #
-      # ==== Block Parameters
-      # * <tt>name</tt>     - The callback to be added.
-      # * <tt>options</tt>  - A hash of options to be used when adding the callback.
-      def _insert_callbacks(callbacks, block = nil)
-        options = callbacks.extract_options!
-        _normalize_callback_options(options)
-        callbacks.push(block) if block
-        callbacks.each do |callback|
-          yield callback, options
-        end
-      end
-
-      ##
-      # :method: before_action
-      #
-      # :call-seq: before_action(names, block)
-      #
-      # Append a callback before actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: prepend_before_action
-      #
-      # :call-seq: prepend_before_action(names, block)
-      #
-      # Prepend a callback before actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: skip_before_action
-      #
-      # :call-seq: skip_before_action(names)
-      #
-      # Skip a callback before actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: append_before_action
-      #
-      # :call-seq: append_before_action(names, block)
-      #
-      # Append a callback before actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: after_action
-      #
-      # :call-seq: after_action(names, block)
-      #
-      # Append a callback after actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: prepend_after_action
-      #
-      # :call-seq: prepend_after_action(names, block)
-      #
-      # Prepend a callback after actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: skip_after_action
-      #
-      # :call-seq: skip_after_action(names)
-      #
-      # Skip a callback after actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: append_after_action
-      #
-      # :call-seq: append_after_action(names, block)
-      #
-      # Append a callback after actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: around_action
-      #
-      # :call-seq: around_action(names, block)
-      #
-      # Append a callback around actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: prepend_around_action
-      #
-      # :call-seq: prepend_around_action(names, block)
-      #
-      # Prepend a callback around actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: skip_around_action
-      #
-      # :call-seq: skip_around_action(names)
-      #
-      # Skip a callback around actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: append_around_action
-      #
-      # :call-seq: append_around_action(names, block)
-      #
-      # Append a callback around actions. See _insert_callbacks for parameter details.
-
-      # set up before_action, prepend_before_action, skip_before_action, etc.
-      # for each of before, after, and around.
-      [:before, :after, :around].each do |callback|
-        define_method "#{callback}_action" do |*names, &blk|
-          _insert_callbacks(names, blk) do |name, options|
-            set_callback(:process_action, callback, name, options)
-          end
-        end
-
-        define_method "prepend_#{callback}_action" do |*names, &blk|
-          _insert_callbacks(names, blk) do |name, options|
-            set_callback(:process_action, callback, name, options.merge(prepend: true))
-          end
-        end
-
-        # Skip a before, after or around callback. See _insert_callbacks
-        # for details on the allowed parameters.
-        define_method "skip_#{callback}_action" do |*names|
-          _insert_callbacks(names) do |name, options|
-            skip_callback(:process_action, callback, name, options)
-          end
-        end
-
-        # *_action is the same as append_*_action
-        alias_method :"append_#{callback}_action", :"#{callback}_action"
-      end
-    end
-  end
-end

data/vendor/rails/actionpack/lib/abstract_controller/collector.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "action_dispatch/http/mime_type"
-
-module AbstractController
-  module Collector
-    def self.generate_method_for_mime(mime)
-      sym = mime.is_a?(Symbol) ? mime : mime.to_sym
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{sym}(*args, &block)
-          custom(Mime[:#{sym}], *args, &block)
-        end
-      RUBY
-    end
-
-    Mime::SET.each do |mime|
-      generate_method_for_mime(mime)
-    end
-
-    Mime::Type.register_callback do |mime|
-      generate_method_for_mime(mime) unless instance_methods.include?(mime.to_sym)
-    end
-
-  private
-
-    def method_missing(symbol, &block)
-      unless mime_constant = Mime[symbol]
-        raise NoMethodError, "To respond to a custom format, register it as a MIME type first: " \
-          "http://guides.rubyonrails.org/action_controller_overview.html#restful-downloads. " \
-          "If you meant to respond to a variant like :tablet or :phone, not a custom format, " \
-          "be sure to nest your variant response within a format response: " \
-          "format.html { |html| html.tablet { ... } }"
-      end
-
-      if Mime::SET.include?(mime_constant)
-        AbstractController::Collector.generate_method_for_mime(mime_constant)
-        send(symbol, &block)
-      else
-        super
-      end
-    end
-  end
-end