actionpack 4.2.10 → 7.2.0.rc1

data/lib/action_controller/metal/rack_delegation.rb

@@ -1,32 +0,0 @@
-require 'action_dispatch/http/request'
-require 'action_dispatch/http/response'
-
-module ActionController
-  module RackDelegation
-    extend ActiveSupport::Concern
-
-    delegate :headers, :status=, :location=, :content_type=,
-             :status, :location, :content_type, :response_code, :to => "@_response"
-
-    def dispatch(action, request)
-      set_response!(request)
-      super(action, request)
-    end
-
-    def response_body=(body)
-      response.body = body if response
-      super
-    end
-
-    def reset_session
-      @_request.reset_session
-    end
-
-    private
-
-    def set_response!(request)
-      @_response         = ActionDispatch::Response.new
-      @_response.request = request
-    end
-  end
-end

data/lib/action_controller/middleware.rb

@@ -1,39 +0,0 @@
-module ActionController
-  class Middleware < Metal
-    class ActionMiddleware
-      def initialize(controller, app)
-        @controller, @app = controller, app
-      end
-
-      def call(env)
-        request = ActionDispatch::Request.new(env)
-        @controller.build(@app).dispatch(:index, request)
-      end
-    end
-
-    class << self
-      alias build new
-
-      def new(app)
-        ActionMiddleware.new(self, app)
-      end
-    end
-
-    attr_internal :app
-
-    def process(action)
-      response = super
-      self.status, self.headers, self.response_body = response if response.is_a?(Array)
-      response
-    end
-
-    def initialize(app)
-      super()
-      @_app = app
-    end
-
-    def index
-      call(env)
-    end
-  end
-end

data/lib/action_controller/model_naming.rb

@@ -1,12 +0,0 @@
-module ActionController
-  module ModelNaming
-    # Converts the given object to an ActiveModel compliant one.
-    def convert_to_model(object)
-      object.respond_to?(:to_model) ? object.to_model : object
-    end
-
-    def model_name_from_record_or_class(record_or_class)
-      convert_to_model(record_or_class).model_name
-    end
-  end
-end

data/lib/action_dispatch/http/parameter_filter.rb

@@ -1,72 +0,0 @@
-module ActionDispatch
-  module Http
-    class ParameterFilter
-      FILTERED = '[FILTERED]'.freeze # :nodoc:
-
-      def initialize(filters = [])
-        @filters = filters
-      end
-
-      def filter(params)
-        compiled_filter.call(params)
-      end
-
-    private
-
-      def compiled_filter
-        @compiled_filter ||= CompiledFilter.compile(@filters)
-      end
-
-      class CompiledFilter # :nodoc:
-        def self.compile(filters)
-          return lambda { |params| params.dup } if filters.empty?
-
-          strings, regexps, blocks = [], [], []
-
-          filters.each do |item|
-            case item
-            when Proc
-              blocks << item
-            when Regexp
-              regexps << item
-            else
-              strings << item.to_s
-            end
-          end
-
-          regexps << Regexp.new(strings.join('|'), true) unless strings.empty?
-          new regexps, blocks
-        end
-
-        attr_reader :regexps, :blocks
-
-        def initialize(regexps, blocks)
-          @regexps = regexps
-          @blocks  = blocks
-        end
-
-        def call(original_params)
-          filtered_params = {}
-
-          original_params.each do |key, value|
-            if regexps.any? { |r| key =~ r }
-              value = FILTERED
-            elsif value.is_a?(Hash)
-              value = call(value)
-            elsif value.is_a?(Array)
-              value = value.map { |v| v.is_a?(Hash) ? call(v) : v }
-            elsif blocks.any?
-              key = key.dup if key.duplicable?
-              value = value.dup if value.duplicable?
-              blocks.each { |b| b.call(key, value) }
-            end
-
-            filtered_params[key] = value
-          end
-
-          filtered_params
-        end
-      end
-    end
-  end
-end

data/lib/action_dispatch/journey/backwards.rb

@@ -1,5 +0,0 @@
-module Rack # :nodoc:
-  Mount = ActionDispatch::Journey::Router
-  Mount::RouteSet = ActionDispatch::Journey::Router
-  Mount::RegexpWithNamedGroups = ActionDispatch::Journey::Path::Pattern
-end

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

@@ -1,76 +0,0 @@
-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 @@
-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([/.?]|[^/.?]+))
-
-            # FIXME: tt.eclosure is not needed for the GTG
-            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,163 +0,0 @@
-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 a generalized transition graph with reduced states. The states
-        # are reduced like a DFA, but the table must be simulated like an NFA.
-        #
-        # Edges of the GTG are regular expressions.
-        def generalized_table
-          gt       = GTG::TransitionTable.new
-          marked   = {}
-          state_id = Hash.new { |h,k| h[k] = h.length }
-          alphabet = self.alphabet
-
-          stack = [eclosure(0)]
-
-          until stack.empty?
-            state = stack.pop
-            next if marked[state] || state.empty?
-
-            marked[state] = true
-
-            alphabet.each do |alpha|
-              next_state = eclosure(following_states(state, alpha))
-              next if next_state.empty?
-
-              gt[state_id[state], state_id[next_state]] = alpha
-              stack << next_state
-            end
-          end
-
-          final_groups = state_id.keys.find_all { |s|
-            s.sort.last == accepting
-          }
-
-          final_groups.each do |states|
-            id = state_id[states]
-
-            gt.add_accepting(id)
-            save = states.find { |s|
-              @memos.key?(s) && eclosure(s).sort.last == accepting
-            }
-
-            gt.add_memo(id, memo(save))
-          end
-
-          gt
-        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 { |x| x.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

data/lib/action_dispatch/journey/router/strexp.rb

@@ -1,27 +0,0 @@
-module ActionDispatch
-  module Journey # :nodoc:
-    class Router # :nodoc:
-      class Strexp # :nodoc:
-        class << self
-          alias :compile :new
-        end
-
-        attr_reader :path, :requirements, :separators, :anchor, :ast
-
-        def self.build(path, requirements, separators, anchor = true)
-          parser = Journey::Parser.new
-          ast = parser.parse path
-          new ast, path, requirements, separators, anchor
-        end
-
-        def initialize(ast, path, requirements, separators, anchor = true)
-          @ast          = ast
-          @path         = path
-          @requirements = requirements
-          @separators   = separators
-          @anchor       = anchor
-        end
-      end
-    end
-  end
-end

data/lib/action_dispatch/middleware/params_parser.rb

@@ -1,60 +0,0 @@
-require 'active_support/core_ext/hash/conversions'
-require 'action_dispatch/http/request'
-require 'active_support/core_ext/hash/indifferent_access'
-
-module ActionDispatch
-  class ParamsParser
-    class ParseError < StandardError
-      attr_reader :original_exception
-
-      def initialize(message, original_exception)
-        super(message)
-        @original_exception = original_exception
-      end
-    end
-
-    DEFAULT_PARSERS = { Mime::JSON => :json }
-
-    def initialize(app, parsers = {})
-      @app, @parsers = app, DEFAULT_PARSERS.merge(parsers)
-    end
-
-    def call(env)
-      if params = parse_formatted_parameters(env)
-        env["action_dispatch.request.request_parameters"] = params
-      end
-
-      @app.call(env)
-    end
-
-    private
-      def parse_formatted_parameters(env)
-        request = Request.new(env)
-
-        return false if request.content_length.zero?
-
-        strategy = @parsers[request.content_mime_type]
-
-        return false unless strategy
-
-        case strategy
-        when Proc
-          strategy.call(request.raw_post)
-        when :json
-          data = ActiveSupport::JSON.decode(request.raw_post)
-          data = {:_json => data} unless data.is_a?(Hash)
-          Request::Utils.deep_munge(data).with_indifferent_access
-        else
-          false
-        end
-      rescue => e # JSON or Ruby code block errors
-        logger(env).debug "Error occurred while parsing request parameters.\nContents:\n\n#{request.raw_post}"
-
-        raise ParseError.new(e.message, e)
-      end
-
-      def logger(env)
-        env['action_dispatch.logger'] || ActiveSupport::Logger.new($stderr)
-      end
-  end
-end

data/lib/action_dispatch/middleware/templates/rescues/_source.erb

@@ -1,27 +0,0 @@
-<% @source_extracts.each_with_index do |source_extract, index| %>
-  <% if source_extract[:code] %>
-    <div class="source <%="hidden" if @show_source_idx != index%>" id="frame-source-<%=index%>">
-      <div class="info">
-        Extracted source (around line <strong>#<%= source_extract[:line_number] %></strong>):
-      </div>
-      <div class="data">
-        <table cellpadding="0" cellspacing="0" class="lines">
-          <tr>
-            <td>
-              <pre class="line_numbers">
-                <% source_extract[:code].each_key do |line_number| %>
-<span><%= line_number -%></span>
-                <% end %>
-              </pre>
-            </td>
-<td width="100%">
-<pre>
-<% source_extract[:code].each do |line, source| -%><div class="line<%= " active" if line == source_extract[:line_number] -%>"><%= source -%></div><% end -%>
-</pre>
-</td>
-          </tr>
-        </table>
-      </div>
-    </div>
-  <% end %>
-<% end %>

data/lib/action_dispatch/testing/assertions/dom.rb

@@ -1,3 +0,0 @@
-require 'active_support/deprecation'
-
-ActiveSupport::Deprecation.warn("ActionDispatch::Assertions::DomAssertions has been extracted to the rails-dom-testing gem.")

data/lib/action_dispatch/testing/assertions/selector.rb

@@ -1,3 +0,0 @@
-require 'active_support/deprecation'
-
-ActiveSupport::Deprecation.warn("ActionDispatch::Assertions::SelectorAssertions has been extracted to the rails-dom-testing gem.")

data/lib/action_dispatch/testing/assertions/tag.rb

@@ -1,3 +0,0 @@
-require 'active_support/deprecation'
-
-ActiveSupport::Deprecation.warn('`ActionDispatch::Assertions::TagAssertions` has been extracted to the rails-dom-testing gem.')