actionpack 3.2.19 → 4.0.0

data/lib/action_dispatch/http/url.rb

@@ -1,19 +1,28 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/hash/slice'
+
 module ActionDispatch
   module Http
     module URL
+      IP_HOST_REGEXP  = /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/
+      HOST_REGEXP     = /(^.*:\/\/)?([^:]+)(?::(\d+$))?/
+      PROTOCOL_REGEXP = /^([^:]+)(:)?(\/\/)?$/
+
       mattr_accessor :tld_length
       self.tld_length = 1
 
       class << self
         def extract_domain(host, tld_length = @@tld_length)
-          return nil unless named_host?(host)
-          host.split('.').last(1 + tld_length).join('.')
+          host.split('.').last(1 + tld_length).join('.') if named_host?(host)
         end
 
         def extract_subdomains(host, tld_length = @@tld_length)
-          return [] unless named_host?(host)
-          parts = host.split('.')
-          parts[0..-(tld_length+2)]
+          if named_host?(host)
+            parts = host.split('.')
+            parts[0..-(tld_length + 2)]
+          else
+            []
+          end
         end
 
         def extract_subdomain(host, tld_length = @@tld_length)
@@ -21,42 +30,62 @@ module ActionDispatch
         end
 
         def url_for(options = {})
-          unless options[:host].present? || options[:only_path].present?
+          options = options.dup
+          path  = options.delete(:script_name).to_s.chomp("/")
+          path << options.delete(:path).to_s
+
+          params = options[:params].is_a?(Hash) ? options[:params] : options.slice(:params)
+          params.reject! { |_,v| v.to_param.nil? }
+
+          result = build_host_url(options)
+          if options[:trailing_slash]
+            if path.include?('?')
+              result << path.sub(/\?/, '/\&')
+            else
+              result << path.sub(/[^\/]\z|\A\z/, '\&/')
+            end
+          else
+            result << path
+          end
+          result << "?#{params.to_query}" unless params.empty?
+          result << "##{Journey::Router::Utils.escape_fragment(options[:anchor].to_param.to_s)}" if options[:anchor]
+          result
+        end
+
+        private
+
+        def build_host_url(options)
+          if options[:host].blank? && options[:only_path].blank?
             raise ArgumentError, 'Missing host to link to! Please provide the :host parameter, set default_url_options[:host], or set :only_path to true'
           end
 
-          rewritten_url = ""
+          result = ""
 
           unless options[:only_path]
-            unless options[:protocol] == false
-              rewritten_url << (options[:protocol] || "http")
-              rewritten_url << ":" unless rewritten_url.match(%r{:|//})
+            if match = options[:host].match(HOST_REGEXP)
+              options[:protocol] ||= match[1] unless options[:protocol] == false
+              options[:host]       = match[2]
+              options[:port]       = match[3] unless options.key?(:port)
             end
-            rewritten_url << "//" unless rewritten_url.match("//")
-            rewritten_url << rewrite_authentication(options)
-            rewritten_url << host_or_subdomain_and_domain(options)
-            rewritten_url << ":#{options.delete(:port)}" if options[:port]
-          end
 
-          path = options.delete(:path) || ''
+            options[:protocol] = normalize_protocol(options)
+            options[:host]     = normalize_host(options)
+            options[:port]     = normalize_port(options)
 
-          params = options[:params] || {}
-          params.reject! {|k,v| v.to_param.nil? }
-
-          if options[:trailing_slash] && !path.ends_with?('/')
-            rewritten_url << path.sub(/(\?|\z)/) { "/" + $& }
-          else
-            rewritten_url << path
+            result << options[:protocol]
+            result << rewrite_authentication(options)
+            result << options[:host]
+            result << ":#{options[:port]}" if options[:port]
           end
-          rewritten_url << "?#{params.to_query}" unless params.empty?
-          rewritten_url << "##{Journey::Router::Utils.escape_fragment(options[:anchor].to_param.to_s)}" if options[:anchor]
-          rewritten_url
+          result
         end
 
-        private
-
         def named_host?(host)
-          !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
+          host && IP_HOST_REGEXP !~ host
+        end
+
+        def same_host?(options)
+          (options[:subdomain] == true || !options.key?(:subdomain)) && options[:domain].nil?
         end
 
         def rewrite_authentication(options)
@@ -67,19 +96,53 @@ module ActionDispatch
           end
         end
 
-        def host_or_subdomain_and_domain(options)
-          return options[:host] if !named_host?(options[:host]) || (options[:subdomain].nil? && options[:domain].nil?)
+        def normalize_protocol(options)
+          case options[:protocol]
+          when nil
+            "http://"
+          when false, "//"
+            "//"
+          when PROTOCOL_REGEXP
+            "#{$1}://"
+          else
+            raise ArgumentError, "Invalid :protocol option: #{options[:protocol].inspect}"
+          end
+        end
+
+        def normalize_host(options)
+          return options[:host] if !named_host?(options[:host]) || same_host?(options)
 
           tld_length = options[:tld_length] || @@tld_length
 
           host = ""
-          unless options[:subdomain] == false
-            host << (options[:subdomain] || extract_subdomain(options[:host], tld_length)).to_param
-            host << "."
+          if options[:subdomain] == true || !options.key?(:subdomain)
+            host << extract_subdomain(options[:host], tld_length).to_param
+          elsif options[:subdomain].present?
+            host << options[:subdomain].to_param
           end
+          host << "." unless host.empty?
           host << (options[:domain] || extract_domain(options[:host], tld_length))
           host
         end
+
+        def normalize_port(options)
+          return nil if options[:port].nil? || options[:port] == false
+
+          case options[:protocol]
+          when "//"
+            nil
+          when "https://"
+            options[:port].to_i == 443 ? nil : options[:port]
+          else
+            options[:port].to_i == 80 ? nil : options[:port]
+          end
+        end
+      end
+
+      def initialize(env)
+        super
+        @protocol = nil
+        @port     = nil
       end
 
       # Returns the complete URL used for this request.
@@ -171,7 +234,7 @@ module ActionDispatch
       # such as 2 to catch <tt>"www"</tt> instead of <tt>"www.rubyonrails"</tt>
       # in "www.rubyonrails.co.uk".
       def subdomain(tld_length = @@tld_length)
-        subdomains(tld_length).join(".")
+        ActionDispatch::Http::URL.extract_subdomain(host, tld_length)
       end
     end
   end

data/lib/action_dispatch/journey/backwards.rb

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

data/lib/action_dispatch/journey/formatter.rb

@@ -0,0 +1,146 @@
+require 'action_controller/metal/exceptions'
+
+module ActionDispatch
+  module Journey
+    # The Formatter class is used for formatting URLs. For example, parameters
+    # passed to +url_for+ in rails will eventually call Formatter#generate.
+    class Formatter # :nodoc:
+      attr_reader :routes
+
+      def initialize(routes)
+        @routes = routes
+        @cache  = nil
+      end
+
+      def generate(type, name, options, recall = {}, parameterize = nil)
+        constraints = recall.merge(options)
+        missing_keys = []
+
+        match_route(name, constraints) do |route|
+          parameterized_parts = extract_parameterized_parts(route, options, recall, parameterize)
+          next if !name && route.requirements.empty? && route.parts.empty?
+
+          missing_keys = missing_keys(route, parameterized_parts)
+          next unless missing_keys.empty?
+          params = options.dup.delete_if do |key, _|
+            parameterized_parts.key?(key) || route.defaults.key?(key)
+          end
+
+          return [route.format(parameterized_parts), params]
+        end
+
+        message = "No route matches #{constraints.inspect}"
+        message << " missing required keys: #{missing_keys.inspect}" if name
+
+        raise ActionController::UrlGenerationError, message
+      end
+
+      def clear
+        @cache = nil
+      end
+
+      private
+
+        def extract_parameterized_parts(route, options, recall, parameterize = nil)
+          parameterized_parts = recall.merge(options)
+
+          keys_to_keep = route.parts.reverse.drop_while { |part|
+            !options.key?(part) || (options[part] || recall[part]).nil?
+          } | route.required_parts
+
+          (parameterized_parts.keys - keys_to_keep).each do |bad_key|
+            parameterized_parts.delete(bad_key)
+          end
+
+          if parameterize
+            parameterized_parts.each do |k, v|
+              parameterized_parts[k] = parameterize.call(k, v)
+            end
+          end
+
+          parameterized_parts.keep_if { |_, v| v }
+          parameterized_parts
+        end
+
+        def named_routes
+          routes.named_routes
+        end
+
+        def match_route(name, options)
+          if named_routes.key?(name)
+            yield named_routes[name]
+          else
+            routes = non_recursive(cache, options.to_a)
+
+            hash = routes.group_by { |_, r| r.score(options) }
+
+            hash.keys.sort.reverse_each do |score|
+              next if score < 0
+
+              hash[score].sort_by { |i, _| i }.each do |_, route|
+                yield route
+              end
+            end
+          end
+        end
+
+        def non_recursive(cache, options)
+          routes = []
+          stack  = [cache]
+
+          while stack.any?
+            c = stack.shift
+            routes.concat(c[:___routes]) if c.key?(:___routes)
+
+            options.each do |pair|
+              stack << c[pair] if c.key?(pair)
+            end
+          end
+
+          routes
+        end
+
+        # Returns an array populated with missing keys if any are present.
+        def missing_keys(route, parts)
+          missing_keys = []
+          tests = route.path.requirements
+          route.required_parts.each { |key|
+            if tests.key?(key)
+              missing_keys << key unless /\A#{tests[key]}\Z/ === parts[key]
+            else
+              missing_keys << key unless parts[key]
+            end
+          }
+          missing_keys
+        end
+
+        def possibles(cache, options, depth = 0)
+          cache.fetch(:___routes) { [] } + options.find_all { |pair|
+            cache.key?(pair)
+          }.map { |pair|
+            possibles(cache[pair], options, depth + 1)
+          }.flatten(1)
+        end
+
+        # Returns +true+ if no missing keys are present, otherwise +false+.
+        def verify_required_parts!(route, parts)
+          missing_keys(route, parts).empty?
+        end
+
+        def build_cache
+          root = { ___routes: [] }
+          routes.each_with_index do |route, i|
+            leaf = route.required_defaults.inject(root) do |h, tuple|
+              h[tuple] ||= {}
+            end
+            (leaf[:___routes] ||= []) << [i, route]
+          end
+          root
+        end
+
+        def cache
+          @cache ||= build_cache
+        end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+require 'action_dispatch/journey/gtg/transition_table'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module GTG # :nodoc:
+      class Builder # :nodoc:
+        DUMMY = Nodes::Dummy.new
+
+        attr_reader :root, :ast, :endpoints
+
+        def initialize(root)
+          @root      = root
+          @ast       = Nodes::Cat.new root, DUMMY
+          @followpos = nil
+        end
+
+        def transition_table
+          dtrans   = TransitionTable.new
+          marked   = {}
+          state_id = Hash.new { |h,k| h[k] = h.length }
+
+          start   = firstpos(root)
+          dstates = [start]
+          until dstates.empty?
+            s = dstates.shift
+            next if marked[s]
+            marked[s] = true # mark s
+
+            s.group_by { |state| symbol(state) }.each do |sym, ps|
+              u = ps.map { |l| followpos(l) }.flatten
+              next if u.empty?
+
+              if u.uniq == [DUMMY]
+                from = state_id[s]
+                to   = state_id[Object.new]
+                dtrans[from, to] = sym
+
+                dtrans.add_accepting(to)
+                ps.each { |state| dtrans.add_memo(to, state.memo) }
+              else
+                dtrans[state_id[s], state_id[u]] = sym
+
+                if u.include?(DUMMY)
+                  to = state_id[u]
+
+                  accepting = ps.find_all { |l| followpos(l).include?(DUMMY) }
+
+                  accepting.each { |accepting_state|
+                    dtrans.add_memo(to, accepting_state.memo)
+                  }
+
+                  dtrans.add_accepting(state_id[u])
+                end
+              end
+
+              dstates << u
+            end
+          end
+
+          dtrans
+        end
+
+        def nullable?(node)
+          case node
+          when Nodes::Group
+            true
+          when Nodes::Star
+            true
+          when Nodes::Or
+            node.children.any? { |c| nullable?(c) }
+          when Nodes::Cat
+            nullable?(node.left) && nullable?(node.right)
+          when Nodes::Terminal
+            !node.left
+          when Nodes::Unary
+            nullable?(node.left)
+          else
+            raise ArgumentError, 'unknown nullable: %s' % node.class.name
+          end
+        end
+
+        def firstpos(node)
+          case node
+          when Nodes::Star
+            firstpos(node.left)
+          when Nodes::Cat
+            if nullable?(node.left)
+              firstpos(node.left) | firstpos(node.right)
+            else
+              firstpos(node.left)
+            end
+          when Nodes::Or
+            node.children.map { |c| firstpos(c) }.flatten.uniq
+          when Nodes::Unary
+            firstpos(node.left)
+          when Nodes::Terminal
+            nullable?(node) ? [] : [node]
+          else
+            raise ArgumentError, 'unknown firstpos: %s' % node.class.name
+          end
+        end
+
+        def lastpos(node)
+          case node
+          when Nodes::Star
+            firstpos(node.left)
+          when Nodes::Or
+            node.children.map { |c| lastpos(c) }.flatten.uniq
+          when Nodes::Cat
+            if nullable?(node.right)
+              lastpos(node.left) | lastpos(node.right)
+            else
+              lastpos(node.right)
+            end
+          when Nodes::Terminal
+            nullable?(node) ? [] : [node]
+          when Nodes::Unary
+            lastpos(node.left)
+          else
+            raise ArgumentError, 'unknown lastpos: %s' % node.class.name
+          end
+        end
+
+        def followpos(node)
+          followpos_table[node]
+        end
+
+        private
+
+          def followpos_table
+            @followpos ||= build_followpos
+          end
+
+          def build_followpos
+            table = Hash.new { |h, k| h[k] = [] }
+            @ast.each do |n|
+              case n
+              when Nodes::Cat
+                lastpos(n.left).each do |i|
+                  table[i] += firstpos(n.right)
+                end
+              when Nodes::Star
+                lastpos(n).each do |i|
+                  table[i] += firstpos(n)
+                end
+              end
+            end
+            table
+          end
+
+          def symbol(edge)
+            case edge
+            when Journey::Nodes::Symbol
+              edge.regexp
+            else
+              edge.left
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'strscan'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module GTG # :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 = [0]
+          while sym = input.scan(%r([/.?]|[^/.?]+))
+            state = tt.move(state, sym)
+          end
+
+          acceptance_states = state.find_all { |s|
+            tt.accepting? s
+          }
+
+          return if acceptance_states.empty?
+
+          memos = acceptance_states.map { |x| tt.memo(x) }.flatten.compact
+
+          MatchData.new(memos)
+        end
+
+        alias :=~    :simulate
+        alias :match :simulate
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+require 'action_dispatch/journey/nfa/dot'
+
+module ActionDispatch
+  module Journey # :nodoc:
+    module GTG # :nodoc:
+      class TransitionTable # :nodoc:
+        include Journey::NFA::Dot
+
+        attr_reader :memos
+
+        def initialize
+          @regexp_states = Hash.new { |h,k| h[k] = {} }
+          @string_states = Hash.new { |h,k| h[k] = {} }
+          @accepting     = {}
+          @memos         = Hash.new { |h,k| h[k] = [] }
+        end
+
+        def add_accepting(state)
+          @accepting[state] = true
+        end
+
+        def accepting_states
+          @accepting.keys
+        end
+
+        def accepting?(state)
+          @accepting[state]
+        end
+
+        def add_memo(idx, memo)
+          @memos[idx] << memo
+        end
+
+        def memo(idx)
+          @memos[idx]
+        end
+
+        def eclosure(t)
+          Array(t)
+        end
+
+        def move(t, a)
+          move_string(t, a).concat(move_regexp(t, a))
+        end
+
+        def to_json
+          require 'json'
+
+          simple_regexp = Hash.new { |h,k| h[k] = {} }
+
+          @regexp_states.each do |from, hash|
+            hash.each do |re, to|
+              simple_regexp[from][re.source] = to
+            end
+          end
+
+          JSON.dump({
+            regexp_states: simple_regexp,
+            string_states: @string_states,
+            accepting:     @accepting
+          })
+        end
+
+        def to_svg
+          svg = IO.popen('dot -Tsvg', 'w+') { |f|
+            f.write(to_dot)
+            f.close_write
+            f.readlines
+          }
+          3.times { svg.shift }
+          svg.join.sub(/width="[^"]*"/, '').sub(/height="[^"]*"/, '')
+        end
+
+        def visualizer(paths, title = 'FSM')
+          viz_dir   = File.join File.dirname(__FILE__), '..', 'visualizer'
+          fsm_js    = File.read File.join(viz_dir, 'fsm.js')
+          fsm_css   = File.read File.join(viz_dir, 'fsm.css')
+          erb       = File.read File.join(viz_dir, 'index.html.erb')
+          states    = "function tt() { return #{to_json}; }"
+
+          fun_routes = paths.shuffle.first(3).map do |ast|
+            ast.map { |n|
+              case n
+              when Nodes::Symbol
+                case n.left
+                when ':id' then rand(100).to_s
+                when ':format' then %w{ xml json }.shuffle.first
+                else
+                  'omg'
+                end
+              when Nodes::Terminal then n.symbol
+              else
+                nil
+              end
+            }.compact.join
+          end
+
+          stylesheets = [fsm_css]
+          svg         = to_svg
+          javascripts = [states, fsm_js]
+
+          # Annoying hack for 1.9 warnings
+          fun_routes  = fun_routes
+          stylesheets = stylesheets
+          svg         = svg
+          javascripts = javascripts
+
+          require 'erb'
+          template = ERB.new erb
+          template.result(binding)
+        end
+
+        def []=(from, to, sym)
+          case sym
+          when String
+            @string_states[from][sym] = to
+          when Regexp
+            @regexp_states[from][sym] = to
+          else
+            raise ArgumentError, 'unknown symbol: %s' % sym.class
+          end
+        end
+
+        def states
+          ss = @string_states.keys + @string_states.values.map(&:values).flatten
+          rs = @regexp_states.keys + @regexp_states.values.map(&:values).flatten
+          (ss + rs).uniq
+        end
+
+        def transitions
+          @string_states.map { |from, hash|
+            hash.map { |s, to| [from, s, to] }
+          }.flatten(1) + @regexp_states.map { |from, hash|
+            hash.map { |s, to| [from, s, to] }
+          }.flatten(1)
+        end
+
+        private
+
+          def move_regexp(t, a)
+            return [] if t.empty?
+
+            t.map { |s|
+              @regexp_states[s].map { |re, v| re === a ? v : nil }
+            }.flatten.compact.uniq
+          end
+
+          def move_string(t, a)
+            return [] if t.empty?
+
+            t.map { |s| @string_states[s][a] }.compact
+          end
+      end
+    end
+  end
+end