omg-actionpack 8.0.0.alpha1

data/lib/action_dispatch/routing/routes_proxy.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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)
+          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.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/lib/action_dispatch/routing/url_for.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module Routing
+    # # Action Dispatch Routing UrlFor
+    #
+    # In `config/routes.rb` 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
+    # `config/routes.rb`.
+    #
+    # **Tip:** If you need to generate URLs from your models or some other place,
+    # then ActionDispatch::Routing::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 ActionDispatch::Routing::UrlFor under the hood. And in
+    # particular, they use the ActionDispatch::Routing::UrlFor#url_for method. One
+    # can generate the same path as the above example by using the following code:
+    #
+    #     include ActionDispatch::Routing::UrlFor
+    #     url_for(controller: 'users',
+    #             action: 'new',
+    #             message: 'Welcome!',
+    #             only_path: true)
+    #     # => "/users/new?message=Welcome%21"
+    #
+    # Notice the `only_path: true` 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 `:host` 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 `:host` argument.
+    #
+    # For convenience, mailers also include ActionDispatch::Routing::UrlFor. So
+    # within mailers, you can use url_for. However, mailers cannot access incoming
+    # web requests in order to derive hostname information, so you have to provide
+    # the `:host` option or set the default host using `default_url_options`. For
+    # more information on url_for in mailers see 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
+    # `config/routes.rb`:
+    #
+    #     resources :users
+    #
+    # This generates, among other things, the method `users_path`. 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 `config/routes.rb`. The following options are supported:
+      #
+      # *   `:only_path` - If true, the relative URL is returned. Defaults to `false`.
+      # *   `:protocol` - The protocol to connect to. Defaults to `"http"`.
+      # *   `:host` - Specifies the host the link should be targeted at. If
+      #     `:only_path` is false, this option must be provided either explicitly, or
+      #     via `default_url_options`.
+      # *   `:subdomain` - 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.
+      # *   `:domain` - Specifies the domain of the link, using the `tld_length` to
+      #     split the domain from the host.
+      # *   `:tld_length` - Number of labels the TLD id composed of, only used if
+      #     `:subdomain` or `:domain` are supplied. Defaults to
+      #     `ActionDispatch::Http::URL.tld_length`, which in turn defaults to 1.
+      # *   `:port` - Optionally specify the port to connect to.
+      # *   `:anchor` - An anchor name to be appended to the path.
+      # *   `:params` - The query parameters to be appended to the path.
+      # *   `:path_params` - The query parameters that will only be used for the named
+      #     dynamic segments of path. If unused, they will be discarded.
+      # *   `:trailing_slash` - If true, adds a trailing slash, as in
+      #     `"/archive/2009/"`.
+      # *   `:script_name` - Specifies application path relative to domain root. If
+      #     provided, prepends application path.
+      #
+      #
+      # Any other key (`:controller`, `:action`, 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
+      # `GET /users/1`:
+      #
+      #     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/lib/action_dispatch/routing.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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 `config/routes.rb`.
+  #
+  # 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 `:id`.
+  #
+  # ## 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
+  # `app/controllers/admin` 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 Routing::Mapper::Resources#resources,
+  # Routing::Mapper::Scoping#namespace, and Routing::Mapper::Scoping#scope.
+  #
+  # ## Non-resourceful routes
+  #
+  # For routes that don't fit the `resources` mold, you can use the HTTP helper
+  # methods `get`, `post`, `patch`, `put` and `delete`.
+  #
+  #     get 'post/:id', to: 'posts#show'
+  #     post 'post/:id', to: 'posts#create_comment'
+  #
+  # Now, if you POST to `/posts/:id`, it will route to the `create_comment`
+  # action. A GET on the same URL will route to the `show` action.
+  #
+  # If your route needs to respond to more than one HTTP method (or all methods)
+  # then using the `:via` option on `match` is preferable.
+  #
+  #     match 'post/:id', to: 'posts#show', via: [:get, :post]
+  #
+  # ## Named routes
+  #
+  # Routes can be named by passing an `:as` 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 `root` 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'    => :list
+  #       get 'blog/delete'  => :delete
+  #       get 'blog/edit'    => :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 `posts#index`, 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 `reload!`.
+  #
+  # ## 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
+  #
+  #     $ bin/rails routes
+  #
+  # Target a specific controller with `-c`, or grep routes using `-g`. Useful in
+  # conjunction with `--expanded` which displays routes vertically.
+  module Routing
+    extend ActiveSupport::Autoload
+
+    autoload :Mapper
+    autoload :RouteSet
+    eager_autoload do
+      autoload :RoutesProxy
+    end
+    autoload :UrlFor
+    autoload :PolymorphicRoutes
+
+    SEPARATORS = %w( / . ? ) # :nodoc:
+    HTTP_METHODS = [:get, :head, :post, :patch, :put, :delete, :options] # :nodoc:
+  end
+end