Class RouteBuilderTest < Test::Unit::TestCase

# File rails/actionpack/test/controller/routing_test.rb, line 968
def build(path, options)
  builder.build(path, options)
end

# File rails/actionpack/test/controller/routing_test.rb, line 964
def builder
  @builder ||= ROUTING::RouteBuilder.new
end

# File rails/actionpack/test/controller/routing_test.rb, line 1050
def test_action_default_should_not_trigger_on_prefix
  s, r = builder.segment_for ':action_name/something/else'
  assert_equal '/something/else', r
  assert_equal :action_name, s.key
  assert_equal nil, s.default
end

# File rails/actionpack/test/controller/routing_test.rb, line 1068
def test_assign_route_options
  segments = builder.segments_for_route_path '/cars/:action/:person/:car/'
  defaults = {:action => 'buy', :person => nil, :car => nil}
  requirements = {:person => %r\w+/, :car => %r\w+/}
  
  route_requirements = builder.assign_route_options(segments, defaults, requirements)
  assert_equal({}, route_requirements)
  
  assert_equal :action, segments[3].key
  assert_equal 'buy', segments[3].default
  
  assert_equal :person, segments[5].key
  assert_equal %r\w+/, segments[5].regexp
  assert segments[5].optional?
  
  assert_equal :car, segments[7].key
  assert_equal %r\w+/, segments[7].regexp
  assert segments[7].optional?
end

# File rails/actionpack/test/controller/routing_test.rb, line 1088
def test_assign_route_options_with_anchor_chars
  segments = builder.segments_for_route_path '/cars/:action/:person/:car/'
  defaults = {:action => 'buy', :person => nil, :car => nil}
  requirements = {:person => %r\w+/, :car => %r^\w+$/}
  
  assert_raises ArgumentError do
    route_requirements = builder.assign_route_options(segments, defaults, requirements)
  end
  
  requirements[:car] = %r[^\/]+/
  route_requirements = builder.assign_route_options(segments, defaults, requirements)
end

# File rails/actionpack/test/controller/routing_test.rb, line 1137
def test_assignment_of_default_options
  segments = builder.segments_for_route_path '/:controller/:action/:id/'
  action, id = segments[-4], segments[-2]
  
  assert_equal :action, action.key
  assert_equal :id, id.key
  assert ! action.optional?
  assert ! id.optional?
  
  builder.assign_default_route_options(segments)
  
  assert_equal 'index', action.default
  assert action.optional?
  assert id.optional?
end

# File rails/actionpack/test/controller/routing_test.rb, line 1153
def test_assignment_of_default_options_respects_existing_defaults
  segments = builder.segments_for_route_path '/:controller/:action/:id/'
  action, id = segments[-4], segments[-2]
  
  assert_equal :action, action.key
  assert_equal :id, id.key
  action.default = 'show'
  action.is_optional = true
  
  id.default = 'Welcome'
  id.is_optional = true
  
  builder.assign_default_route_options(segments)
  
  assert_equal 'show', action.default
  assert action.optional?
  assert_equal 'Welcome', id.default
  assert id.optional?
end

# File rails/actionpack/test/controller/routing_test.rb, line 1173
def test_assignment_of_default_options_respects_regexps
  segments = builder.segments_for_route_path '/:controller/:action/:id/'
  action = segments[-4]
  
  assert_equal :action, action.key
  action.regexp = %rshow|in/ # Use 'in' to check partial matches
  
  builder.assign_default_route_options(segments)
  
  assert_equal nil, action.default
  assert ! action.optional?
end

# File rails/actionpack/test/controller/routing_test.rb, line 1186
def test_assignment_of_is_optional_when_default
  segments = builder.segments_for_route_path '/books/:action.rss'
  assert_equal segments[3].key, :action
  segments[3].default = 'changes'
  builder.ensure_required_segments(segments)
  assert ! segments[3].optional?
end

# File rails/actionpack/test/controller/routing_test.rb, line 1057
def test_divide_route_options
  segments = builder.segments_for_route_path '/cars/:action/:person/:car/'
  defaults, requirements = builder.divide_route_options(segments,
    :action => 'buy', :person => %r\w+/, :car => %r\w+/,
    :defaults => {:person => nil, :car => nil}
  )
  
  assert_equal({:action => 'buy', :person => nil, :car => nil}, defaults)
  assert_equal({:person => %r\w+/, :car => %r\w+/}, requirements)
end

# File rails/actionpack/test/controller/routing_test.rb, line 1194
def test_is_optional_is_assigned_to_default_segments
  segments = builder.segments_for_route_path '/books/:action'
  builder.assign_route_options(segments, {:action => 'index'}, {})
  
  assert_equal segments[3].key, :action
  assert segments[3].optional?
  assert_kind_of ROUTING::DividerSegment, segments[2]
  assert segments[2].optional?
end

# File rails/actionpack/test/controller/routing_test.rb, line 1102
def test_optional_segments_preceding_required_segments
  segments = builder.segments_for_route_path '/cars/:action/:person/:car/'
  defaults = {:action => 'buy', :person => nil, :car => "model-t"}
  assert builder.assign_route_options(segments, defaults, {}).empty?
  
  0.upto(1) { |i| assert !segments[i].optional?, "segment #{i} is optional and it shouldn't be" }
  assert segments[2].optional?
  
  assert_equal nil, builder.warn_output # should only warn on the :person segment
end

# File rails/actionpack/test/controller/routing_test.rb, line 972
def test_options_should_not_be_modified
  requirements1 = { :id => %r\w+/, :controller => %r(?:[a-z](?:-?[a-z]+)*)/ }
  requirements2 = requirements1.dup

  assert_equal requirements1, requirements2

  with_options(:controller => 'folder',
               :requirements => requirements2) do |m|
    m.build 'folders/new', :action => 'new'
  end

  assert_equal requirements1, requirements2
end

# File rails/actionpack/test/controller/routing_test.rb, line 1207
def test_route_build
  ActionController::Routing.with_controllers %w(users pages) do
    r = builder.build '/:controller/:action/:id/', :action => nil
    
    [0, 2, 4].each do |i|
      assert_kind_of ROUTING::DividerSegment, r.segments[i]
      assert_equal '/', r.segments[i].value
      assert r.segments[i].optional? if i > 1
    end
    
    assert_kind_of ROUTING::DynamicSegment, r.segments[1]
    assert_equal :controller, r.segments[1].key
    assert_equal nil, r.segments[1].default
    
    assert_kind_of ROUTING::DynamicSegment, r.segments[3]
    assert_equal :action, r.segments[3].key
    assert_equal 'index', r.segments[3].default
    
    assert_kind_of ROUTING::DynamicSegment, r.segments[5]
    assert_equal :id, r.segments[5].key
    assert r.segments[5].optional?
  end
end

# File rails/actionpack/test/controller/routing_test.rb, line 993
def test_segment_for_action
  segment, rest = builder.segment_for ':action'
  assert_equal '', rest
  assert_kind_of ROUTING::DynamicSegment, segment
  assert_equal :action, segment.key
  assert_equal 'index', segment.default
end

# File rails/actionpack/test/controller/routing_test.rb, line 1001
def test_segment_for_dynamic
  segment, rest = builder.segment_for ':login'
  assert_equal '', rest
  assert_kind_of ROUTING::DynamicSegment, segment
  assert_equal :login, segment.key
  assert_equal nil, segment.default
  assert ! segment.optional?
end

# File rails/actionpack/test/controller/routing_test.rb, line 986
def test_segment_for_static
  segment, rest = builder.segment_for 'ulysses'
  assert_equal '', rest
  assert_kind_of ROUTING::StaticSegment, segment
  assert_equal 'ulysses', segment.value
end

# File rails/actionpack/test/controller/routing_test.rb, line 1010
def test_segment_for_with_rest
  segment, rest = builder.segment_for ':login/:action'
  assert_equal :login, segment.key
  assert_equal '/:action', rest
  segment, rest = builder.segment_for rest
  assert_equal '/', segment.value
  assert_equal ':action', rest
  segment, rest = builder.segment_for rest
  assert_equal :action, segment.key
  assert_equal '', rest
end

# File rails/actionpack/test/controller/routing_test.rb, line 1122
def test_segmentation_of_dot_path
  segments = builder.segments_for_route_path '/books/:action.rss'
  assert builder.assign_route_options(segments, {}, {}).empty?
  assert_equal 6, segments.length # "/", "books", "/", ":action", ".", "rss"
  assert !segments.any? { |seg| seg.optional? }
end

# File rails/actionpack/test/controller/routing_test.rb, line 1129
def test_segmentation_of_dynamic_dot_path
  segments = builder.segments_for_route_path '/books/:action.:format'
  assert builder.assign_route_options(segments, {}, {}).empty?
  assert_equal 6, segments.length # "/", "books", "/", ":action", ".", ":format"
  assert !segments.any? { |seg| seg.optional? }
  assert_kind_of ROUTING::DynamicSegment, segments.last
end

# File rails/actionpack/test/controller/routing_test.rb, line 1113
def test_segmentation_of_semicolon_path
  segments = builder.segments_for_route_path '/books/:id;:action'
  defaults = { :action => 'show' }
  assert builder.assign_route_options(segments, defaults, {}).empty?
  segments.each do |segment|
    assert ! segment.optional? || segment.key == :action
  end
end

# File rails/actionpack/test/controller/routing_test.rb, line 1022
def test_segments_for
  segments = builder.segments_for_route_path '/:controller/:action/:id'
  
  assert_kind_of ROUTING::DividerSegment, segments[0]
  assert_equal '/', segments[2].value
  
  assert_kind_of ROUTING::DynamicSegment, segments[1]
  assert_equal :controller, segments[1].key
  
  assert_kind_of ROUTING::DividerSegment, segments[2]
  assert_equal '/', segments[2].value
  
  assert_kind_of ROUTING::DynamicSegment, segments[3]
  assert_equal :action, segments[3].key
  
  assert_kind_of ROUTING::DividerSegment, segments[4]
  assert_equal '/', segments[4].value
  
  assert_kind_of ROUTING::DynamicSegment, segments[5]
  assert_equal :id, segments[5].key
end

# File rails/actionpack/test/controller/routing_test.rb, line 1231
def test_slashes_are_implied
  routes = [
    builder.build('/:controller/:action/:id/', :action => nil),
    builder.build('/:controller/:action/:id', :action => nil),
    builder.build(':controller/:action/:id', :action => nil),
    builder.build('/:controller/:action/:id/', :action => nil)
  ]
  expected = routes.first.segments.length
  routes.each_with_index do |route, i|
    found = route.segments.length
    assert_equal expected, found, "Route #{i + 1} has #{found} segments, expected #{expected}"
  end
end