active_link_to 1.0.0 → 1.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Oleg Khabarov, The Working Group Inc.
+Copyright (c) 2009-13 Oleg Khabarov, The Working Group Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,103 +1,126 @@
-active\_link\_to
-================
-
+# 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'.
 
 ## Install
-
 When installing for Rails 3 applications add this to the Gemfile: `gem 'active_link_to'` and run `bundle install`.
 
 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.
 
 ## Super Simple Example
-Here's a link that will have class attached if it happens to be rendered 
-on page with path `/users` or any child of that page like `/users/123`
+Here's a link that will have a class attached if it happens to be rendered 
+on page with path `/users` or any child of that page, like `/users/123`
 
-    active_link_to 'Users', '/users'
-    # => <a href="/users" class="active">Users</a>
+```ruby
+active_link_to 'Users', '/users'
+# => <a href="/users" class="active">Users</a>
+```
 
 This is exactly the same as:
 
-    active_link_to 'Users', '/users', :active => :inclusive
-    # => <a href="/users" class="active">Users</a>
+```ruby
+active_link_to 'Users', '/users', :active => :inclusive
+# => <a href="/users" class="active">Users</a>
+```
 
 ## Active Options
-Here's available options that can be used as the `:active` value
+Here's a list of available options that can be used as the `:active` value
 
+```
 * Boolean                 -> true | false
 * Symbol                  -> :exclusive | :inclusive
 * Regex                   -> /regex/
-* Controller/Action Pair  -> [[:controller], [:action\_a, :action\_b]]
+* Controller/Action Pair  -> [[:controller], [:action_a, :action_b]]
+```
 
 ## 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: /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>
+We want to highlight a link that matches immediate url, but not the children
+nodes. Most commonly used for 'home' links.
+   
+```ruby 
+# For URL: /users will be active
+active_link_to 'Users', users_path, :active => :exclusive
+# => <a href="/users" class="active">Users</a>
+```
+
+```ruby
+# 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 'use':
-    
-    active_link_to 'Users', users_path, :active => /^\/use/
+
+```ruby
+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:
+   
+```ruby 
+# For matching multiple controllers and actions:
+active_link_to 'User Edit', edit_user_path(@user), :active => [['people', 'news'], ['show', 'edit']]
+
+# for matching all actions under given controllers:
+active_link_to 'User Edit', edit_user_path(@user), :active => [['people', 'news'], []]
+
+# for matching all controllers for a particular action
+active_link_to 'User Edit', edit_user_path(@user), :active => [[], ['edit']]
+```
     
-    # For matching multiple controllers and actions:
-    active_link_to 'User Edit', edit_user_path(@user), :active => [['people', 'news'], ['show', 'edit']]
-    
-    # for matching all actions under given controllers:
-    active_link_to 'User Edit', edit_user_path(@user), :active => [['people', 'news'], []]
-    
-    # for matching all controllers for a particular action
-    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
+Sometimes it should be as easy as giving link true or false value:
+
+```ruby
+active_link_to 'Users', users_path, :active => true
+```
     
 ## More Options
 You can specify active and inactive css classes for links:
+
+```ruby
+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>
+```
     
-    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>
+Sometimes you want to replace link tag with a span if it's active:
+
+```ruby
+active_link_to 'Users', users_path, :disable_active => true
+# => <span class="active">Users</span>
+```
+
+If you are constructing navigation menu it might be helpful to wrap links in another tag, like `<li>`:
+
+```ruby
+active_link_to 'Users', users_path, :wrap_tag => :li
+# => <li class="active"><a href="/users">Users</a></li>
+```
     
 ## Helper Methods
 You may directly use methods that `active_link_to` relies on. 
 
 `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
+```ruby
+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'
+```
+active_link_to_class(users_path, :active => :inclusive)
+# => 'active'
+```
 
 ### Copyright
 
-Copyright (c) 2009 Oleg Khabarov, The Working Group Inc. See LICENSE for details.
+Copyright (c) 2009-13 Oleg Khabarov, The Working Group Inc. See LICENSE for details.

data/Rakefile

@@ -1,27 +1,10 @@
 require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    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']
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
 require 'rake/testtask'
+
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
   test.pattern = 'test/**/*_test.rb'
   test.verbose = true
 end
 
-task :test    => :check_dependencies
 task :default => :test

data/active_link_to.gemspec

@@ -1,44 +1,20 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
-Gem::Specification.new do |s|
-  s.name = %q{active_link_to}
-  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-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 = [
-    "LICENSE",
-    "README.md"
-  ]
-  s.files = [
-    "LICENSE",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "active_link_to.gemspec",
-    "init.rb",
-    "lib/active_link_to.rb",
-    "test/active_link_to_test.rb",
-    "test/test_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/twg/active_link_to}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.2}
-  s.summary = %q{Marks currently active links}
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'active_link_to/version'
 
+Gem::Specification.new do |s|
+  s.name          = "active_link_to"
+  s.version       = ActiveLinkTo::VERSION
+  s.authors       = ["Oleg Khabarov"]
+  s.email         = ["oleg@khabarov.ca"]
+  s.homepage      = "http://github.com/twg/active_link_to"
+  s.summary       = "ActionView helper to render currently active links"
+  s.description   = "Helpful method 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.files         = `git ls-files`.split("\n")
+  s.platform      = Gem::Platform::RUBY
+  s.require_paths = ['lib']
+  
+  s.add_dependency 'actionpack'
+end

data/lib/active_link_to.rb

@@ -1,98 +1,2 @@
-module ActiveLinkTo
-  
-  
-  # 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)
-      options       = args[0] || {}
-      html_options  = args[1] || {}
-    else
-      name          = args[0]
-      options       = args[1] || {}
-      html_options  = args[2] || {}
-    end
-    url = url_for(options)
-    
-    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
-    
-    css_class = link_options.delete(:class).to_s + ' '
-    css_class << active_link_to_class(url, active_options)
-    css_class.strip!
-    
-    wrap_tag = active_options[:wrap_tag].present? ? active_options[:wrap_tag] : nil
-    link_options[:class] = css_class if css_class.present? && !wrap_tag
-    
-    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, 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 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[:class_inactive] || ''
-    end
-  end
-  
-  # 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 :exclusive
-      !request.fullpath.match(/^#{Regexp.escape(url)}\/?(\?.*)?$/).blank?
-    when Regexp
-      !request.fullpath.match(condition).blank?
-    when Array
-      controllers = [*condition[0]]
-      actions     = [*condition[1]]
-      (controllers.blank? || controllers.member?(params[:controller])) &&
-      (actions.blank? || actions.member?(params[:action]))
-    when TrueClass
-      true
-    when FalseClass
-      false
-    end
-  end
-  
-end
-
-ActionView::Base.send :include, ActiveLinkTo
+require 'active_link_to/active_link_to'
+require 'active_link_to/version'

data/lib/active_link_to/active_link_to.rb

@@ -0,0 +1,96 @@
+module ActiveLinkTo
+  
+  # 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)
+      options       = args[0] || {}
+      html_options  = args[1] || {}
+    else
+      name          = args[0]
+      options       = args[1] || {}
+      html_options  = args[2] || {}
+    end
+    url = url_for(options)
+
+    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
+
+    css_class = link_options.delete(:class).to_s + ' '
+    css_class << active_link_to_class(url, active_options)
+    css_class.strip!
+
+    wrap_tag = active_options[:wrap_tag].present? ? active_options[:wrap_tag] : nil
+    link_options[:class] = css_class if css_class.present?
+
+    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, 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 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[:class_inactive] || ''
+    end
+  end
+
+  # 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).chomp('/')}(\/.*|\?.*)?$/).blank?
+    when :exclusive
+      !request.fullpath.match(/^#{Regexp.escape(url)}\/?(\?.*)?$/).blank?
+    when Regexp
+      !request.fullpath.match(condition).blank?
+    when Array
+      controllers = [*condition[0]]
+      actions     = [*condition[1]]
+      (controllers.blank? || controllers.member?(params[:controller])) &&
+      (actions.blank? || actions.member?(params[:action]))
+    when TrueClass
+      true
+    when FalseClass
+      false
+    end
+  end
+end
+
+ActionView::Base.send :include, ActiveLinkTo

data/lib/active_link_to/version.rb

@@ -0,0 +1,3 @@
+module ActiveLinkTo
+  VERSION = "1.0.1"
+end

data/test/active_link_to_test.rb

@@ -1,71 +1,81 @@
 require 'test_helper'
 
 class ActiveLinkToTest < Test::Unit::TestCase
-  
+
   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_last_slash
+    request.fullpath = '/root/abc'
+    assert is_active_link?('/root/')
+  end
+
+  def test_is_active_link_symbol_inclusive_with_last_slash_and_similar_path
+    request.fullpath = '/root_path'
+    assert !is_active_link?('/root/')
+  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']])
@@ -73,71 +83,71 @@ class ActiveLinkToTest < Test::Unit::TestCase
     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')
-    
+
     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
-    
+    assert_equal '<a class="active" href="/root">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
-    
+    assert_equal '<a class="current active" href="/root">label</a>', link
+
     link = active_link_to('label', '/other', :class => 'current')
-    assert_equal '<a href="/other" class="current">label</a>', link
+    assert_equal '<a class="current" href="/other">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
-    
+    assert_equal '<a class="on" href="/root">label</a>', link
+
     link = active_link_to('label', '/other', :class_inactive => 'off')
-    assert_equal '<a href="/other" class="off">label</a>', link
+    assert_equal '<a class="off" href="/other">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
-    
+    assert_equal '<li class="active"><a class="active" 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
-    
+    assert_equal '<li class="active"><span class="active">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
+    assert_equal '<li class="testing active"><a class="testing active" 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 = '/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 '<a class="testing active" href="/root">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: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,29 +9,44 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-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
-  the link (or more often navigation item) is selected based on the current page or
-  other arbitrary condition
-email: oleg@theworkinggroup.ca
+date: 2013-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Helpful method 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
+email:
+- oleg@khabarov.ca
 executables: []
 extensions: []
-extra_rdoc_files:
-- LICENSE
-- README.md
+extra_rdoc_files: []
 files:
+- .gitignore
+- Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- VERSION
 - active_link_to.gemspec
-- init.rb
 - lib/active_link_to.rb
+- lib/active_link_to/active_link_to.rb
+- lib/active_link_to/version.rb
 - test/active_link_to_test.rb
 - test/test_helper.rb
-has_rdoc: true
 homepage: http://github.com/twg/active_link_to
 licenses: []
 post_install_message: 
@@ -52,8 +67,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Marks currently active links
+summary: ActionView helper to render currently active links
 test_files: []

data/VERSION

@@ -1 +0,0 @@
-1.0.0

data/init.rb

@@ -1 +0,0 @@
-require 'active_link_to'