class ActionDispatch::Journey::Path::Pattern

def self.build(path, requirements, separators, anchored)
  parser = Journey::Parser.new
  ast = parser.parse path
  new ast, requirements, separators, anchored
end

def self.from_string string
  build(string, {}, "/.?", true)
end

def ast
  @spec.find_all(&:symbol?).each do |node|
    re = @requirements[node.to_sym]
    node.regexp = re if re
  end
  @spec.find_all(&:star?).each do |node|
    node = node.left
    node.regexp = @requirements[node.to_sym] || /(.+)/
  end
  @spec
end

def build_formatter
  Visitors::FormatBuilder.new.accept(spec)
end

def initialize(ast, requirements, separators, anchored)
  @spec         = ast
  @requirements = requirements
  @separators   = separators
  @anchored     = anchored
  @names          = nil
  @optional_names = nil
  @required_names = nil
  @re             = nil
  @offsets        = nil
end

def match(other)
  return unless match = to_regexp.match(other)
  MatchData.new(names, offsets, match)
end

def names
  @names ||= spec.find_all(&:symbol?).map(&:name)
end

def offsets
  return @offsets if @offsets
  @offsets = [0]
  spec.find_all(&:symbol?).each do |node|
    node = node.to_sym
    if @requirements.key?(node)
      re = /#{@requirements[node]}|/
      @offsets.push((re.match('').length - 1) + @offsets.last)
    else
      @offsets << @offsets.last
    end
  end
  @offsets
end

def optional_names
  @optional_names ||= spec.find_all(&:group?).flat_map { |group|
    group.find_all(&:symbol?)
  }.map(&:name).uniq
end

def regexp_visitor
  @anchored ? AnchoredRegexp : UnanchoredRegexp
end

def required_names
  @required_names ||= names - optional_names
end

def source
  to_regexp.source
end

def to_regexp
  @re ||= regexp_visitor.new(@separators, @requirements).accept spec
end