active_link_to 0.0.10 → 1.0.0

data/README.md

@@ -1,127 +1,102 @@
 active\_link\_to
 ================
 
-Creates a link tag of the given name using a URL created by the set of
-options. Please see documentation for `link_to`, as `active_link_to` is
-basically a wrapper for it. This method accepts an optional :active
-parameter that dictates if the given link will have an extra css class
-attached that marks it as 'active'.
+Creates a link tag of the given name using a URL created by the set of options. Please see documentation for `link_to`, as `active_link_to` is basically a wrapper for it. This method accepts an optional :active parameter that dictates if the given link will have an extra css class attached that marks it as 'active'.
 
 ## Install
-### In Rails 3.*
 
-In Gemfile
+When installing for Rails 3 applications add this to the Gemfile: `gem 'active_link_to'` and run `bundle install`.
 
-    gem 'active_link_to'
-    
-and run `bundle install`
-
-### In older Rails
-  
-    $ sudo gem install active_link_to
-
-Then you probably want to declare it in your environment.rb
+For older Rails apps add `config.gem 'active_link_to'` in config/environment.rb and run `rake gems:install`. Or just checkout this repo into /vendor/plugins directory.
 
-    config.gem 'active_link_to'
-  
-and freeze it (preferably):
-
-    $ rake gems:unpack GEM=active_link_to
-
-### Super Simple Example
+## Super Simple Example
 Here's a link that will have class attached if it happens to be rendered 
-on page with path `/people` or any child of that page like `/people/123`
+on page with path `/users` or any child of that page like `/users/123`
 
-    active_link_to 'People', '/people'
-    # => <a href="/people" class="active">People</a>
+    active_link_to 'Users', '/users'
+    # => <a href="/users" class="active">Users</a>
 
 This is exactly the same as:
 
-    active_link_to 'People', '/people', :active => { :when => :self }
-    # => <a href="/people" class="active">People</a>
+    active_link_to 'Users', '/users', :active => :inclusive
+    # => <a href="/users" class="active">Users</a>
 
-### Options
-Here's available options that can be inserted into `:active` hash
+## Active Options
+Here's available options that can be used as the `:active` value
 
-* `:when => predefined symbol || Regexp || Array tuple of controller/actions || Boolean` - This controls
-  when link is considered to be 'active'
-* `:active_class => 'class_name'` - When link is 'active', css
-  class of that link is set to the default 'active'. This parameter 
-  allows it to be changed
-* `:inactive_class => 'class_name'` - Opposite of the :active_class
-  By default it's blank. However you can change it to whatever you want.
-* `:disable_link => Boolean` - When link is active, sometimes you
-  want to render span tag instead of the link. This parameter is for that.
+* Boolean                 -> true | false
+* Symbol                  -> :exclusive | :inclusive
+* Regex                   -> /regex/
+* Controller/Action Pair  -> [[:controller], [:action\_a, :action\_b]]
 
-### Examples
+## More Examples
 Most of the functionality of `active_link_to` depends on the current
 url. Specifically, `request.fullpath` value. We covered the basic example
 already, so let's try something more fun.
 
 We want to highlight the link that matches immediate url, and not the children
 nodes as well
-
-    # For URL: /people/24
-    active_link_to 'People', people_path, :active => { :when => :self_only }
-    # => <a href="/people">People</a>
-
-    # For URL: /people
-    active_link_to 'People', people_path, :active => { :when => :self_only }
-    # => <a href="/people" class="active">People</a>
-
+    
+    # For URL: /users will be active
+    active_link_to 'Users', users_path, :active => :exclusive
+    # => <a href="/users" class="active">Users</a>
+    
+    # But for URL: /users/123 it will not be active
+    active_link_to 'Users', users_path, :active => :exclusive
+    # => <a href="/users">Users</a>
+    
 If we need to set link to be active based on some regular expression, we can do
-that as well. Let's try to activate links urls of which begin with 'peop':
-
-    # For URL: /people/44
-    active_link_to 'People', people_path, :active => { :when => /^peop/ }
-    # => <a href="/people" class="active">People</a>
-
-    # For URL: /aliens/9
-    active_link_to 'People', people_path, :active => { :when => /^peop/ }
-    # => <a href="/people">People</a>
-
+that as well. Let's try to activate links urls of which begin with 'use':
+    
+    active_link_to 'Users', users_path, :active => /^\/use/
+    
 What if we need to mark link active for all URLs that match a particular controller,
 or action, or both? Or any number of those at the same time? Sure, why not:
-
-    # For URL: /people/56/edit
+    
     # For matching multiple controllers and actions:
-    active_link_to 'Person Edit', edit_person_path(@person), :active => {
-      :when => [['people', 'aliens'], ['show', 'edit']]
-    }
-
+    active_link_to 'User Edit', edit_user_path(@user), :active => [['people', 'news'], ['show', 'edit']]
+    
     # for matching all actions under given controllers:
-    active_link_to 'Person Edit', edit_person_path(@person), :active => {
-      :when => [['people', 'aliens'], []]
-    }
-
+    active_link_to 'User Edit', edit_user_path(@user), :active => [['people', 'news'], []]
+    
     # for matching all controllers for a particular action
-    active_link_to 'Person Edit', edit_person_path(@person), :active => {
-      :when => [[], ['edit']]
-    }
-    # => <a href="/people" class="active">People</a>
-
+    active_link_to 'User Edit', edit_user_path(@user), :active => [[], ['edit']]
+    
 Sometimes it should be easy as setting a true or false:
+    
+    active_link_to 'Users', users_path, :active => true
+    
+## More Options
+You can specify active and inactive css classes for links:
+    
+    active_link_to 'Users', users_path, :class_active => 'enabled'
+    # => <a href="/users" class="enabled">Users</a>
+    
+    active_link_to 'News', news_path, :class_inactive => 'disabled'
+    # => <a href="/news" class="disabled">News</a>
+    
+Sometimes you want to replace link with a span if it's active:
+    
+    active_link_to 'Users', users_path, :disable_active => true
+    # => <span class="active">Users</span>
+    
+If you are constructing navigation links it's helpful to wrap links in another tag, like `<li>` maybe:
+    
+    active_link_to 'Users', users_path, :wrap_link => :li
+    # => <li class="active"><a href="/users">Users</a></li>
+    
+## Helper Methods
+You may directly use methods that `active_link_to` relies on. 
 
-    active_link_to 'People', people_path, :active => { :when => true }
-    # => <a href="/people" class="active">People</a>
-
-    active_link_to 'People', people_path, :active => { :when => false }
-    # => <a href="/people">People</a>
-
-Lets see what happens when we push some css class modifier parameters
-
-    # For URL: /people/12
-    active_link_to 'People', people_path, :active => { :active_link => 'awesome_selected' }
-    # => <a href="/people" class="awesome_selected">People</a>
-
-    active_link_to 'Aliens', aliens_path, :active => { :inactive_link => 'bummer_inactive' }
-    # => <a href="/aliens" class="bummer_inactive">Aliens</a>
-
-Some weird people think that link should change to a span if it indicated current page:
-
-    # For URL: /people
-    active_link_to 'People', people_path, :active => { :disable_link => true }
-    # => <span class="active">People</span>
+`is_active_link?` will return true or false based on the URL and value of the `:active` parameter:
+    
+    is_active_link?(users_path, :inclusive)
+    # => true
+    
+`active_link_to_class` will return the css class:
+    
+    active_link_to_class(users_path, :active => :inclusive)
+    # => 'active'
 
 ### Copyright
 

data/Rakefile

@@ -4,17 +4,16 @@ require 'rake'
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
-    gem.name = 'active_link_to'
-    gem.summary = 'Marks currently active links'
+    gem.name        = 'active_link_to'
+    gem.summary     = 'Marks currently active links'
     gem.description = 'Extremely helpful when you need to add some logic that figures out if the link (or more often navigation item) is selected based on the current page or other arbitrary condition'
-    gem.email = "oleg@theworkinggroup.ca"
-    gem.homepage = "http://github.com/twg/active_link_to"
-    gem.authors = ["Oleg Khabarov"]
+    gem.email       = 'oleg@theworkinggroup.ca'
+    gem.homepage    = 'http://github.com/twg/active_link_to'
+    gem.authors     = ['Oleg Khabarov']
   end
-  
   Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
 require 'rake/testtask'
@@ -24,33 +23,5 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/*_test.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
-
-task :test => :check_dependencies
-
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION')
-    version = File.read('VERSION')
-  else
-    version = ""
-  end
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "active_link_to #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+task :test    => :check_dependencies
+task :default => :test

data/VERSION

@@ -1 +1 @@
-0.0.10
+1.0.0

data/active_link_to.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{active_link_to}
-  s.version = "0.0.10"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Oleg Khabarov"]
-  s.date = %q{2011-07-19}
+  s.date = %q{2011-07-22}
   s.description = %q{Extremely helpful when you need to add some logic that figures out if the link (or more often navigation item) is selected based on the current page or other arbitrary condition}
   s.email = %q{oleg@theworkinggroup.ca}
   s.extra_rdoc_files = [

data/lib/active_link_to.rb

@@ -1,105 +1,15 @@
 module ActiveLinkTo
   
-  # Creates a link tag of the given +name+ using a URL created by the set of
-  # +options+. Please see documentation for link_to, as active_link_to is
-  # basically a wrapper for it. This method accepts an optional +:active+
-  # parameter that dictates if the given link will have an extra css class
-  # attached that marks it as 'active'.
-  #
-  # === Super Simple Example
-  # Here's a link that will have class attached if it happens to be rendered 
-  # on page with path /people or any child of that page like /people/123
-  # 
-  #   active_link_to 'People', '/people'
-  #   # => <a href="/people" class="active">People</a>
-  #
-  # This is exactly the same as:
-  #
-  #   active_link_to 'People', '/people', :active => { :when => :self }
-  #   # => <a href="/people" class="active">People</a>
-  #
-  # === Options
-  # Here's available options that can be inserted into :active hash
-  # * <tt>:when => predefined symbol || Regexp || Array tuple of controller/actions || Boolean</tt> - This controls
-  #   when link is considered to be 'active'
-  # * <tt>:active_class => 'class_name'</tt> - When link is 'active', css
-  #   class of that link is set to the default 'active'. This parameter 
-  #   allows it to be changed
-  # * <tt>:inactive_class => 'class_name'</tt> - Opposite of the :active_class
-  #   By default it's blank. However you can change it to whatever you want.
-  # * <tt>:disable_link => Boolean</tt> - When link is active, sometimes you
-  #   want to render span tag instead of the link. This parameter is for that.
-  #
-  # === Examples
-  # Most of the functionality of active_link_helper depends on the current
-  # url. Specifically, request.request_uri value. We covered the basic example
-  # already, so let's try sometihng more fun
-  # 
-  # We want to highlight the link that matches immidiate url, and not the children
-  # nodes as well
-  #
-  #   # For URL: /people/24
-  #   active_link_to 'People', people_path, :active => { :when => :self_only }
-  #   # => <a href="/people">People</a>
-  #
-  #   # For URL: /people
-  #   active_link_to 'People', people_path, :active => { :when => :self_only }
-  #   # => <a href="/people" class="active">People</a>
-  #
-  # If we need to set link to be active based on some regular expression, we can do
-  # that as well. Let's try to activate links urls of which begin with 'peop':
-  # 
-  #   # For URL: /people/44
-  #   active_link_to 'People', people_path, :active => { :when => /^peop/ }
-  #   # => <a href="/people" class="active">People</a>
-  # 
-  #   # For URL: /aliens/9
-  #   active_link_to 'People', people_path, :active => { :when => /^peop/ }
-  #   # => <a href="/people">People</a>
-  #
-  # What if we need to mark link active for all URLs that match a particular controller,
-  # or action, or both? Or any number of those at the same time? Sure, why not:
-  #
-  #   # For URL: /people/56/edit
-  #   # For matching multiple controllers and actions:
-  #   active_link_to 'Person Edit', edit_person_path(@person), :active => {
-  #     :when => [['people', 'aliens'], ['show', 'edit']]
-  #   }
-  #
-  #   # for matching all actions under given controllers:
-  #   active_link_to 'Person Edit', edit_person_path(@person), :active => {
-  #     :when => [['people', 'aliens'], []]
-  #   }
-  #
-  #   # for matching all controllers for a particular action
-  #   active_link_to 'Person Edit', edit_person_path(@person), :active => {
-  #     :when => [[], ['edit']]
-  #   }
-  #   # => <a href="/people" class="active">People</a>
-  #
-  # Sometimes it should be easy as setting a true or false:
-  #
-  #   active_link_to 'People', people_path, :active => { :when => true }
-  #   # => <a href="/people" class="active">People</a>
-  #
-  #   active_link_to 'People', people_path, :active => { :when => false }
-  #   # => <a href="/people">People</a>
-  #
-  # Lets see what happens when we push some css class modifier parameters
-  #
-  #   # For URL: /people/12
-  #   active_link_to 'People', people_path, :active => { :active_link => 'awesome_selected' }
-  #   # => <a href="/people" class="awesome_selected">People</a>
-  #
-  #   active_link_to 'Aliens', aliens_path, :active => { :inactive_link => 'bummer_inactive' }
-  #   # => <a href="/aliens" class="bummer_inactive">Aliens</a>
-  #
-  # Some wierd people think that link should change to a span if it indicated current page:
-  #
-  #   # For URL: /people
-  #   active_link_to 'People', people_path, :active => { :disable_link => true }
-  #   # => <span class="active">People</span>
-  #   
+  
+  # Wrapper around link_to. Accepts following params:
+  #   :active         => Boolean | Symbol | Regex | Controller/Action Pair
+  #   :class_active   => String
+  #   :class_inactive => String
+  #   :disable_active => Boolean
+  #   :wrap_tag       => Symbol
+  # Example usage:
+  #   active_link_to('/users', :class_active => 'enabled')
+  #   active_link_to(users_path, :active => :exclusive, :wrap_tag => :li)
   def active_link_to(*args, &block)
     if block_given?
       name          = capture(&block)
@@ -110,47 +20,70 @@ module ActiveLinkTo
       options       = args[1] || {}
       html_options  = args[2] || {}
     end
+    url = url_for(options)
     
-    options = options.clone
-    html_options = html_options.clone
+    active_options  = { }
+    link_options    = { }
+    html_options.each do |k, v|
+      if [:active, :class_active, :class_inactive, :active_disable, :wrap_tag].member?(k)
+        active_options[k] = v
+      else
+        link_options[k] = v
+      end
+    end
     
-    url = url_for(options)
-    active_link_options = html_options.delete(:active) || {}
-    css_class = active_class(url, active_link_options)
+    css_class = link_options.delete(:class).to_s + ' '
+    css_class << active_link_to_class(url, active_options)
+    css_class.strip!
     
-    html_options[:class] ||= ''
-    html_options[:class] += " #{css_class}" if !css_class.blank?
-    html_options[:class].blank? ? html_options.delete(:class) : html_options[:class].lstrip!
+    wrap_tag = active_options[:wrap_tag].present? ? active_options[:wrap_tag] : nil
+    link_options[:class] = css_class if css_class.present? && !wrap_tag
     
-    if active_link_options[:disable_link] === true && is_active_link?(url, active_link_options)
-      content_tag(:span, name, html_options)
+    link = if active_options[:active_disable] === true && is_active_link?(url, active_options[:active])
+      content_tag(:span, name, link_options)
     else
-      link_to(name, url, html_options)
+      link_to(name, url, link_options)
     end
+    
+    wrap_tag ? content_tag(wrap_tag, link, :class => css_class) : link
   end
   
-  # Returns css class name. Takes the link's URL and :active paramers
-  def active_class(url, options = {})
-    if is_active_link?(url, options)
-      options[:active_class] || 'active'
+  # Returns css class name. Takes the link's URL and its params
+  # Example usage:
+  #   active_link_to_class('/root', :class_active => 'on', :class_inactive => 'off')
+  #
+  def active_link_to_class(url, options = {})
+    if is_active_link?(url, options[:active])
+      options[:class_active] || 'active'
     else
-      options[:inactive_class] || ''
+      options[:class_inactive] || ''
     end
   end
   
-  # Returns true or false. Takes the link's URL and :active parameters
-  def is_active_link?(url, options = {})
-    url = url.sub(/\?.*/, '')
-    case options[:when]
-    when :self, nil
+  # Returns true or false based on the provided path and condition
+  # Possible condition values are:
+  #                  Boolean -> true | false
+  #                   Symbol -> :exclusive | :inclusive
+  #                    Regex -> /regex/
+  #   Controller/Action Pair -> [[:controller], [:action_a, :action_b]]
+  # Example usage:
+  #   is_active_link?('/root', true)
+  #   is_active_link?('/root', :exclusive)
+  #   is_active_link?('/root', /^\/root/)
+  #   is_active_link?('/root', ['users', ['show', 'edit']])
+  #
+  def is_active_link?(url, condition = nil)
+    url = url_for(url).sub(/\?.*/, '') # ignore GET params
+    case condition
+    when :inclusive, nil
       !request.fullpath.match(/^#{Regexp.escape(url)}(\/.*|\?.*)?$/).blank?
-    when :self_only
+    when :exclusive
       !request.fullpath.match(/^#{Regexp.escape(url)}\/?(\?.*)?$/).blank?
     when Regexp
-      !request.fullpath.match(options[:when]).blank?
+      !request.fullpath.match(condition).blank?
     when Array
-      controllers = [*options[:when][0]]
-      actions     = [*options[:when][1]]
+      controllers = [*condition[0]]
+      actions     = [*condition[1]]
       (controllers.blank? || controllers.member?(params[:controller])) &&
       (actions.blank? || actions.member?(params[:action]))
     when TrueClass

data/test/active_link_to_test.rb

@@ -2,120 +2,142 @@ require 'test_helper'
 
 class ActiveLinkToTest < Test::Unit::TestCase
   
-  def test_matching_self
-    request.fullpath = '/test'
-    out = active_link_to 'name', '/test'
-    assert_equal '<a href="/test" class="active">name</a>', out
-    out = active_link_to 'name', '/test', :active => { :when => :self }
-    assert_equal '<a href="/test" class="active">name</a>', out
-    out = active_link_to 'name', '/not-test'
-    assert_equal '<a href="/not-test">name</a>', out
-  end
-  
-  def test_matching_self_with_similar_url
-    request.fullpath = '/test/19'
-    out = active_link_to 'name', '/test/1'
-    assert_equal '<a href="/test/1">name</a>', out
-  end
-  
-  def test_matching_self_with_extra_parameters
-    request.fullpath = '/test?status=what'
-    out = active_link_to 'name', '/test'
-    assert_equal '<a href="/test" class="active">name</a>', out
-    request.fullpath = '/test/?status=what'
-    out = active_link_to 'name', '/test'
-    assert_equal '<a href="/test" class="active">name</a>', out
-  end
-  
-  def test_matching_self_with_extra_params_in_the_link
-    request.fullpath = '/test?status=what'
-    out = active_link_to 'name', '/test?what=status'
-    assert_equal '<a href="/test?what=status" class="active">name</a>', out
-  end
-  
-  def test_matching_self_only
-    request.fullpath = '/test/fail'
-    out = active_link_to 'name', '/test/fail', :active => { :when => :self_only }
-    assert_equal '<a href="/test/fail" class="active">name</a>', out
-    out = active_link_to 'name', '/test', :active => { :when => :self_only }
-    assert_equal '<a href="/test">name</a>', out
-  end
-  
-  def test_matching_self_only_with_extra_parameters
-    request.fullpath = '/test/fail?why=because'
-    out = active_link_to 'name', '/test/fail', :active => { :when => :self_only }
-    assert_equal '<a href="/test/fail" class="active">name</a>', out
-  end
-  
-  def test_matching_custom_regex
-    request.fullpath = '/test/something_else'
-    out = active_link_to 'name', '/test', :active => { :when => /^\/te/}
-    assert_equal '<a href="/test" class="active">name</a>', out
-    out = active_link_to 'name', '/test', :active => { :when => /^\/no/}
-    assert_equal '<a href="/test">name</a>', out
-  end
-  
-  def test_matching_controller_action_singular_values
-    request.fullpath = '/test/23'
-    params[:controller], params[:action] = 'tests', 'show'
-    out = active_link_to 'name', '/test/23', :active => { :when => ['tests', ['show', 'edit']]}
-    assert_equal '<a href="/test/23" class="active">name</a>', out
-    out = active_link_to 'name', '/test/23', :active => { :when => [ 'tests' ]}
-    assert_equal '<a href="/test/23" class="active">name</a>', out
-    out = active_link_to 'name', '/test/23', :active => { :when => [nil, 'show']}
-    assert_equal '<a href="/test/23" class="active">name</a>', out
-    out = active_link_to 'name', '/test/23', :active => { :when => ['tests', 'update']}
-    assert_equal '<a href="/test/23">name</a>', out
-  end
-  
-  def test_matching_controller_action_touples
-    request.fullpath = '/test/23'
-    params[:controller], params[:action] = 'tests', 'show'
-    out = active_link_to 'name', '/test/23', :active => { :when => [['tests'], ['show', 'edit']]}
-    assert_equal '<a href="/test/23" class="active">name</a>', out
-    out = active_link_to 'name', '/test/23', :active => { :when => [['tests'], []]}
-    assert_equal '<a href="/test/23" class="active">name</a>', out
-    out = active_link_to 'name', '/test/23', :active => { :when => [[], ['show']]}
-    assert_equal '<a href="/test/23" class="active">name</a>', out
-    out = active_link_to 'name', '/test/23', :active => { :when => [['tests'], ['update']]}
-    assert_equal '<a href="/test/23">name</a>', out
-  end
-  
-  def test_matching_booleans
-    request.fullpath = 'doesnotmatter'
-    out = active_link_to 'name', '/test', :active => { :when => true }
-    assert_equal '<a href="/test" class="active">name</a>', out
-    out = active_link_to 'name', '/test', :active => { :when => false }
-    assert_equal '<a href="/test">name</a>', out
-  end
-  
-  def test_setting_active_class
-    request.fullpath = '/test'
-    out = active_link_to 'name', '/test', :active => { :active_class => 'new_active'}
-    assert_equal '<a href="/test" class="new_active">name</a>', out
-  end
-  
-  def test_setting_inactive_class
-    request.fullpath = '/test'
-    out = active_link_to 'name', '/not-test', :active => { :inactive_class => 'new_inactive'}
-    assert_equal '<a href="/not-test" class="new_inactive">name</a>', out
-  end
-  
-  def test_transforming_to_span
-    request.fullpath = '/test'
-    out = active_link_to 'name', '/test', :active => { :disable_link => true }
-    assert_equal '<span class="active">name</span>', out
+  def test_is_active_link_booleans
+    assert is_active_link?('/', true)
+    assert !is_active_link?('/', false)
+  end
+  
+  def test_is_active_link_symbol_inclusive
+    request.fullpath = '/root'
+    assert is_active_link?('/root', :inclusive)
+    
+    request.fullpath = '/root?param=test'
+    assert is_active_link?('/root', :inclusive)
+    
+    request.fullpath = '/root/child/sub-child'
+    assert is_active_link?('/root', :inclusive)
+    
+    request.fullpath = '/other'
+    assert !is_active_link?('/root', :inclusive)
+  end
+  
+  def test_is_active_link_symbol_inclusive_implied
+    request.fullpath = '/root/child/sub-child'
+    assert is_active_link?('/root')
+  end
+  
+  def test_is_active_link_symbol_inclusive_similar_path
+    request.fullpath = '/root/abc'
+    assert !is_active_link?('/root/a', :inclusive)
+  end
+  
+  def test_is_active_link_symbol_inclusive_with_link_params
+    request.fullpath = '/root?param=test'
+    assert is_active_link?('/root?attr=example')
+  end
+  
+  def test_is_active_link_symbol_exclusive
+    request.fullpath = '/root'
+    assert is_active_link?('/root', :exclusive)
+    
+    request.fullpath = '/root?param=test'
+    assert is_active_link?('/root', :exclusive)
+    
+    request.fullpath = '/root/child'
+    assert !is_active_link?('/root', :exclusive)
+  end
+  
+  def test_is_active_link_symbol_exclusive_with_link_params
+    request.fullpath = '/root?param=test'
+    assert is_active_link?('/root?attr=example', :exclusive)
+  end
+  
+  def test_is_active_link_regex
+    request.fullpath = '/root'
+    assert is_active_link?('/', /^\/root/)
+    
+    request.fullpath = '/root/child'
+    assert is_active_link?('/', /^\/r/)
+    
+    request.fullpath = '/other'
+    assert !is_active_link?('/', /^\/r/)
+  end
+  
+  def test_is_active_link_array
+    params[:controller], params[:action] = 'controller', 'action'
+    
+    assert is_active_link?('/', [['controller'], ['action']])
+    assert is_active_link?('/', [['controller'], ['action', 'action_b']])
+    assert is_active_link?('/', [['controller', 'controller_b'], ['action']])
+    assert is_active_link?('/', [['controller', 'controller_b'], ['action', 'action_b']])
+    assert is_active_link?('/', ['controller', 'action'])
+    assert is_active_link?('/', ['controller', ['action', 'action_b']])
+    assert is_active_link?('/', [['controller', 'controller_b'], 'action'])
+    
+    assert !is_active_link?('/', ['controller_a', 'action'])
+    assert !is_active_link?('/', ['controller', 'action_a'])
+  end
+  
+  def test_active_link_to_class
+    request.fullpath = '/root'
+    assert_equal 'active', active_link_to_class('/root')
+    assert_equal 'on', active_link_to_class('/root', :class_active => 'on')
     
-    out = active_link_to 'name', '/other', :active => { :disable_link => true }
-    assert_equal '<a href="/other">name</a>', out
+    assert_equal '', active_link_to_class('/other')
+    assert_equal 'off', active_link_to_class('/other', :class_inactive => 'off')
+  end
+  
+  def test_active_link_to
+    request.fullpath = '/root'
+    link = active_link_to('label', '/root')
+    assert_equal '<a href="/root" class="active">label</a>', link
+    
+    link = active_link_to('label', '/other')
+    assert_equal '<a href="/other">label</a>', link
+  end
+  
+  def test_active_link_to_with_existing_class
+    request.fullpath = '/root'
+    link = active_link_to('label', '/root', :class => 'current')
+    assert_equal '<a href="/root" class="current active">label</a>', link
+    
+    link = active_link_to('label', '/other', :class => 'current')
+    assert_equal '<a href="/other" class="current">label</a>', link
+  end
+  
+  def test_active_link_to_with_custom_classes
+    request.fullpath = '/root'
+    link = active_link_to('label', '/root', :class_active => 'on')
+    assert_equal '<a href="/root" class="on">label</a>', link
+    
+    link = active_link_to('label', '/other', :class_inactive => 'off')
+    assert_equal '<a href="/other" class="off">label</a>', link
+  end
+  
+  def test_active_link_to_with_wrap_tag
+    request.fullpath = '/root'
+    link = active_link_to('label', '/root', :wrap_tag => :li)
+    assert_equal '<li class="active"><a href="/root">label</a></li>', link
+    
+    link = active_link_to('label', '/root', :wrap_tag => :li, :active_disable => true)
+    assert_equal '<li class="active"><span>label</span></li>', link
+    
+    link = active_link_to('label', '/root', :wrap_tag => :li, :class => 'testing')
+    assert_equal '<li class="testing active"><a href="/root">label</a></li>', link
+  end
+  
+  def test_active_link_to_with_active_disable
+    request.fullpath = '/root'
+    link = active_link_to('label', '/root', :active_disable => true)
+    assert_equal '<span class="active">label</span>', link
   end
   
   def test_should_not_modify_passed_params
-    request.fullpath = '/test'
-    params = {:class => 'testing'}
-    out = active_link_to 'name', '/test', params
-    assert_equal '<a href="/test" class="testing active">name</a>', out
-    assert_equal ({:class => 'testing'}), params
+    request.fullpath = '/root'
+    params = { :class => 'testing', :active => :inclusive }
+    out = active_link_to 'label', '/root', params
+    assert_equal '<a href="/root" class="testing active">label</a>', out
+    assert_equal ({:class => 'testing', :active => :inclusive }), params
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_link_to
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-19 00:00:00.000000000 -04:00
+date: 2011-07-22 00:00:00.000000000 -04:00
 default_executable: 
 dependencies: []
 description: Extremely helpful when you need to add some logic that figures out if