class ActionDispatch::Journey::Route

def self.build(name, app, path, constraints, required_defaults, defaults)
  request_method_match = verb_matcher(constraints.delete(:request_method))
  new name, app, path, constraints, required_defaults, defaults, request_method_match, 0, {}
end

def self.verb_matcher(verb)
  VerbMatchers::VERB_TO_CLASS.fetch(verb) do
    VerbMatchers::Unknown.new verb.to_s.dasherize.upcase
  end
end

def ast
  @decorated_ast ||= begin
    decorated_ast = path.ast
    decorated_ast.find_all(&:terminal?).each { |n| n.memo = self }
    decorated_ast
  end
end

def dispatcher?
  @app.dispatcher?
end

def eager_load!
  path.eager_load!
  ast
  parts
  required_defaults
  nil
end

def format(path_options)
  @path_formatter.evaluate path_options
end

def glob?
  !path.spec.grep(Nodes::Star).empty?
end

def initialize(name, app, path, constraints, required_defaults, defaults, request_method_match, precedence, scope_options, internal = false)
  @name        = name
  @app         = app
  @path        = path
  @request_method_match = request_method_match
  @constraints = constraints
  @defaults    = defaults
  @required_defaults = nil
  @_required_defaults = required_defaults
  @required_parts    = nil
  @parts             = nil
  @decorated_ast     = nil
  @precedence        = precedence
  @path_formatter    = @path.build_formatter
  @scope_options     = scope_options
  @internal          = internal
end

def ip
  constraints[:ip] || //
end

def match_verb(request)
  @request_method_match.any? { |m| m.call request }
end

def matches?(request)
  match_verb(request) &&
  constraints.all? { |method, value|
    case value
    when Regexp, String
      value === request.send(method).to_s
    when Array
      value.include?(request.send(method))
    when TrueClass
      request.send(method).present?
    when FalseClass
      request.send(method).blank?
    else
      value === request.send(method)
    end
  }
end

def parts
  @parts ||= segments.map(&:to_sym)
end

def required_default?(key)
  @_required_defaults.include?(key)
end

def required_defaults
  @required_defaults ||= @defaults.dup.delete_if do |k, _|
    parts.include?(k) || !required_default?(k)
  end
end

def required_keys
  required_parts + required_defaults.keys
end

def required_parts
  @required_parts ||= path.required_names.map(&:to_sym)
end

def requirements
  @defaults.merge(path.requirements).delete_if { |_, v|
    /.+?/ == v
  }
end

def requires_matching_verb?
  !@request_method_match.all? { |x| x == VerbMatchers::All }
end

def score(supplied_keys)
  required_keys = path.required_names
  required_keys.each do |k|
    return -1 unless supplied_keys.include?(k)
  end
  score = 0
  path.names.each do |k|
    score += 1 if supplied_keys.include?(k)
  end
  score + (required_defaults.length * 2)
end

def segments
  path.names
end

def verb
  verbs.join("|")
end

def verbs
  @request_method_match.map(&:verb)
end