actionpack 6.0.3.2 → 6.1.0

data/lib/action_controller/metal/force_ssl.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/slice"
-
-module ActionController
-  # This module is deprecated in favor of +config.force_ssl+ in your environment
-  # config file. This will ensure all endpoints not explicitly marked otherwise
-  # will have all communication served over HTTPS.
-  module ForceSSL # :nodoc:
-    extend ActiveSupport::Concern
-    include AbstractController::Callbacks
-
-    ACTION_OPTIONS = [:only, :except, :if, :unless]
-    URL_OPTIONS = [:protocol, :host, :domain, :subdomain, :port, :path]
-    REDIRECT_OPTIONS = [:status, :flash, :alert, :notice]
-
-    module ClassMethods # :nodoc:
-      def force_ssl(options = {})
-        ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
-          Controller-level `force_ssl` is deprecated and will be removed from
-          Rails 6.1. Please enable `config.force_ssl` in your environment
-          configuration to enable the ActionDispatch::SSL middleware to more
-          fully enforce that your application communicate over HTTPS. If needed,
-          you can use `config.ssl_options` to exempt matching endpoints from
-          being redirected to HTTPS.
-        MESSAGE
-
-        action_options = options.slice(*ACTION_OPTIONS)
-        redirect_options = options.except(*ACTION_OPTIONS)
-        before_action(action_options) do
-          force_ssl_redirect(redirect_options)
-        end
-      end
-    end
-
-    def force_ssl_redirect(host_or_options = nil)
-      unless request.ssl?
-        options = {
-          protocol: "https://",
-          host: request.host,
-          path: request.fullpath,
-          status: :moved_permanently,
-        }
-
-        if host_or_options.is_a?(Hash)
-          options.merge!(host_or_options)
-        elsif host_or_options
-          options[:host] = host_or_options
-        end
-
-        secure_url = ActionDispatch::Http::URL.url_for(options.slice(*URL_OPTIONS))
-        flash.keep if respond_to?(:flash) && request.respond_to?(:flash)
-        redirect_to secure_url, options.slice(*REDIRECT_OPTIONS)
-      end
-    end
-  end
-end

data/lib/action_dispatch/http/parameter_filter.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/deprecation/constant_accessor"
-require "active_support/parameter_filter"
-
-module ActionDispatch
-  module Http
-    include ActiveSupport::Deprecation::DeprecatedConstantAccessor
-    deprecate_constant "ParameterFilter", "ActiveSupport::ParameterFilter",
-      message: "ActionDispatch::Http::ParameterFilter is deprecated and will be removed from Rails 6.1. Use ActiveSupport::ParameterFilter instead."
-  end
-end

data/lib/action_dispatch/journey/nfa/builder.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "action_dispatch/journey/nfa/transition_table"
-require "action_dispatch/journey/gtg/transition_table"
-
-module ActionDispatch
-  module Journey # :nodoc:
-    module NFA # :nodoc:
-      class Visitor < Visitors::Visitor # :nodoc:
-        def initialize(tt)
-          @tt = tt
-          @i  = -1
-        end
-
-        def visit_CAT(node)
-          left  = visit(node.left)
-          right = visit(node.right)
-
-          @tt.merge(left.last, right.first)
-
-          [left.first, right.last]
-        end
-
-        def visit_GROUP(node)
-          from  = @i += 1
-          left  = visit(node.left)
-          to    = @i += 1
-
-          @tt.accepting = to
-
-          @tt[from, left.first] = nil
-          @tt[left.last, to] = nil
-          @tt[from, to] = nil
-
-          [from, to]
-        end
-
-        def visit_OR(node)
-          from = @i += 1
-          children = node.children.map { |c| visit(c) }
-          to = @i += 1
-
-          children.each do |child|
-            @tt[from, child.first] = nil
-            @tt[child.last, to]    = nil
-          end
-
-          @tt.accepting = to
-
-          [from, to]
-        end
-
-        def terminal(node)
-          from_i = @i += 1 # new state
-          to_i   = @i += 1 # new state
-
-          @tt[from_i, to_i] = node
-          @tt.accepting = to_i
-          @tt.add_memo(to_i, node.memo)
-
-          [from_i, to_i]
-        end
-      end
-
-      class Builder # :nodoc:
-        def initialize(ast)
-          @ast = ast
-        end
-
-        def transition_table
-          tt = TransitionTable.new
-          Visitor.new(tt).accept(@ast)
-          tt
-        end
-      end
-    end
-  end
-end

data/lib/action_dispatch/journey/nfa/simulator.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "strscan"
-
-module ActionDispatch
-  module Journey # :nodoc:
-    module NFA # :nodoc:
-      class MatchData # :nodoc:
-        attr_reader :memos
-
-        def initialize(memos)
-          @memos = memos
-        end
-      end
-
-      class Simulator # :nodoc:
-        attr_reader :tt
-
-        def initialize(transition_table)
-          @tt = transition_table
-        end
-
-        def simulate(string)
-          input = StringScanner.new(string)
-          state = tt.eclosure(0)
-          until input.eos?
-            sym   = input.scan(%r([/.?]|[^/.?]+))
-            state = tt.eclosure(tt.move(state, sym))
-          end
-
-          acceptance_states = state.find_all { |s|
-            tt.accepting?(tt.eclosure(s).sort.last)
-          }
-
-          return if acceptance_states.empty?
-
-          memos = acceptance_states.flat_map { |x| tt.memo(x) }.compact
-
-          MatchData.new(memos)
-        end
-
-        alias :=~    :simulate
-        alias :match :simulate
-      end
-    end
-  end
-end

data/lib/action_dispatch/journey/nfa/transition_table.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require "action_dispatch/journey/nfa/dot"
-
-module ActionDispatch
-  module Journey # :nodoc:
-    module NFA # :nodoc:
-      class TransitionTable # :nodoc:
-        include Journey::NFA::Dot
-
-        attr_accessor :accepting
-        attr_reader :memos
-
-        def initialize
-          @table     = Hash.new { |h, f| h[f] = {} }
-          @memos     = {}
-          @accepting = nil
-          @inverted  = nil
-        end
-
-        def accepting?(state)
-          accepting == state
-        end
-
-        def accepting_states
-          [accepting]
-        end
-
-        def add_memo(idx, memo)
-          @memos[idx] = memo
-        end
-
-        def memo(idx)
-          @memos[idx]
-        end
-
-        def []=(i, f, s)
-          @table[f][i] = s
-        end
-
-        def merge(left, right)
-          @memos[right] = @memos.delete(left)
-          @table[right] = @table.delete(left)
-        end
-
-        def states
-          (@table.keys + @table.values.flat_map(&:keys)).uniq
-        end
-
-        # Returns set of NFA states to which there is a transition on ast symbol
-        # +a+ from some state +s+ in +t+.
-        def following_states(t, a)
-          Array(t).flat_map { |s| inverted[s][a] }.uniq
-        end
-
-        # Returns set of NFA states to which there is a transition on ast symbol
-        # +a+ from some state +s+ in +t+.
-        def move(t, a)
-          Array(t).map { |s|
-            inverted[s].keys.compact.find_all { |sym|
-              sym === a
-            }.map { |sym| inverted[s][sym] }
-          }.flatten.uniq
-        end
-
-        def alphabet
-          inverted.values.flat_map(&:keys).compact.uniq.sort_by(&:to_s)
-        end
-
-        # Returns a set of NFA states reachable from some NFA state +s+ in set
-        # +t+ on nil-transitions alone.
-        def eclosure(t)
-          stack = Array(t)
-          seen  = {}
-          children = []
-
-          until stack.empty?
-            s = stack.pop
-            next if seen[s]
-
-            seen[s] = true
-            children << s
-
-            stack.concat(inverted[s][nil])
-          end
-
-          children.uniq
-        end
-
-        def transitions
-          @table.flat_map { |to, hash|
-            hash.map { |from, sym| [from, sym, to] }
-          }
-        end
-
-        private
-          def inverted
-            return @inverted if @inverted
-
-            @inverted = Hash.new { |h, from|
-              h[from] = Hash.new { |j, s| j[s] = [] }
-            }
-
-            @table.each { |to, hash|
-              hash.each { |from, sym|
-                if sym
-                  sym = Nodes::Symbol === sym ? sym.regexp : sym.left
-                end
-
-                @inverted[from][sym] << to
-              }
-            }
-
-            @inverted
-          end
-      end
-    end
-  end
-end