active_link_to 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b138b65cf5484c2189fadada7df67d2d4866b6c
-  data.tar.gz: a236a8a8fe79a8997bd14a1f325a91665d9659b7
+  metadata.gz: fd9a67de186dfcf5e517ed55994051723962da91
+  data.tar.gz: 153e11c947d56e41e642e45a94295581a868c7f7
 SHA512:
-  metadata.gz: a7df0c88235eb79306d046d474fd0f2fa561d17e6ff00c4e0bc124c40417c4fef22798c62330c75b40efc71e2a2e40357f6f398a974c4d279c354c9139f93d83
-  data.tar.gz: 572bdf400d1dfdafcc9aae908b7254264f7b865241e01c1b20c24fc13fc25a89225c6a6eb7fcb79175c9b5d4747a2308103dda972e35e34cd08268e6fba144fb
+  metadata.gz: 421d92f774bf0e904a8dede4c10910bc2fcd28ae9c7e39cc8f3142628557827224e3aa4bfbb9a67ba52527498e8cdf3e6525f814298cf26140d1ec6406ae3b7c
+  data.tar.gz: 771b308ba2db04c506d3d7870c98be228388c09dfd8e79f0915721eeba9303f452014d4d4334f72d42f914ab49a7690e7b1ee1bdf0a2027386612ffc7fa45b9f

data/LICENSE

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

data/README.md

@@ -4,7 +4,7 @@
 Creates a link tag of the given name using a URL created by the set of options. Please see documentation for [link_to](http://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-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`.
+When installing for Rails 3/4/5 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.
 
@@ -20,7 +20,7 @@ active_link_to 'Users', '/users'
 This is exactly the same as:
 
 ```ruby
-active_link_to 'Users', '/users', :active => :inclusive
+active_link_to 'Users', '/users', active: :inclusive
 # => <a href="/users" class="active">Users</a>
 ```
 
@@ -28,15 +28,18 @@ active_link_to 'Users', '/users', :active => :inclusive
 Here's a list of available options that can be used as the `:active` value
 
 ```
-* Boolean                 -> true | false
-* Symbol                  -> :exclusive | :inclusive | :exact
-* Regex                   -> /regex/
-* Controller/Action Pair  -> [[:controller], [:action_a, :action_b]]
+<<<<<<< HEAD
+* Boolean                         -> true | false
+* Symbol                          -> :exclusive | :inclusive | :exact
+* Regex                           -> /regex/
+* Controller/Action Pair          -> [[:controller], [:action_a, :action_b]]
+* Controller/Specific Action Pair -> [controller: :action_a, controller_b: :action_b]
+* Hash                            -> { param_a: 1, param_b: 2 }
 ```
 
 ## More Examples
 Most of the functionality of `active_link_to` depends on the current
-url. Specifically, `request.fullpath` value. We covered the basic example
+url. Specifically, `request.original_fullpath` value. We covered the basic example
 already, so let's try something more fun.
 
 We want to highlight a link that matches immediate url, but not the children
@@ -44,13 +47,13 @@ nodes. Most commonly used for 'home' links.
 
 ```ruby
 # For URL: /users will be active
-active_link_to 'Users', users_path, :active => :exclusive
+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
+active_link_to 'Users', users_path, active: :exclusive
 # => <a href="/users">Users</a>
 ```
 
@@ -58,14 +61,14 @@ 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':
 
 ```ruby
-active_link_to 'Users', users_path, :active => /^\/use/
+active_link_to 'Users', users_path, active: /^\/use/
 ```
 
-If we need to set link to be active based on an exact match, we can do
-that as well:
+If we need to set link to be active based on an exact match, for example on
+filter made via a query string, we can do that as well:
 
 ```ruby
-active_link_to 'Users', users_path, :active => :exact
+active_link_to 'Users', users_path(role_eq: 'admin'), active: :exact
 ```
 
 What if we need to mark link active for all URLs that match a particular controller,
@@ -73,44 +76,60 @@ 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']]
+active_link_to 'User Edit', edit_user_path(@user), active: [['people', 'news'], ['show', 'edit']]
+
+# For matching specific controllers and actions:
+active_link_to 'User Edit', edit_user_path(@user), :active => [people: :show, news: :edit]
 
 # for matching all actions under given controllers:
-active_link_to 'User Edit', edit_user_path(@user), :active => [['people', 'news'], []]
+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']]
+active_link_to 'User Edit', edit_user_path(@user), active: [[], ['edit']]
 ```
 
 Sometimes it should be as easy as giving link true or false value:
 
 ```ruby
-active_link_to 'Users', users_path, :active => true
+active_link_to 'Users', users_path, active: true
+```
+
+If we need to set link to be active based on `params`, we can do that as well:
+
+```ruby
+active_link_to 'Admin users', users_path(role_eq: 'admin'), :active => { role_eq: 'admin' }
 ```
 
 ## More Options
 You can specify active and inactive css classes for links:
 
 ```ruby
-active_link_to 'Users', users_path, :class_active => 'enabled'
+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'
+active_link_to 'News', news_path, class_inactive: 'disabled'
 # => <a href="/news" class="disabled">News</a>
 ```
 
 Sometimes you want to replace link tag with a span if it's active:
 
 ```ruby
-active_link_to 'Users', users_path, :active_disable => true
+active_link_to 'Users', users_path, active_disable: 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" class="active">Users</a></li>
+active_link_to 'Users', users_path, wrap_tag: :li
+# => <li class="active"><a href="/users">Users</a></li>
+```
+
+You can specify css classes for the `wrap_tag`:
+
+```ruby
+active_link_to 'Users', users_path, wrap_tag: :li, wrap_class: 'nav-item'
+# => <li class="nav-item active"><a href="/users">Users</a></li>
 ```
 
 ## Helper Methods
@@ -126,10 +145,10 @@ is_active_link?(users_path, :inclusive)
 `active_link_to_class` will return the css class:
 
 ```
-active_link_to_class(users_path, :active => :inclusive)
+active_link_to_class(users_path, active: :inclusive)
 # => 'active'
 ```
 
 ### Copyright
 
-Copyright (c) 2009-15 Oleg Khabarov, The Working Group Inc. See LICENSE for details.
+Copyright (c) 2009-17 Oleg Khabarov. See LICENSE for details.

data/Rakefile

@@ -8,4 +8,4 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-task :default => :test
+task default: :test

data/active_link_to.gemspec

@@ -11,10 +11,11 @@ Gem::Specification.new do |s|
   s.homepage      = "http://github.com/comfy/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
+  s.add_dependency 'addressable'
+end

data/lib/active_link_to.rb

@@ -1,2 +1,3 @@
+require 'addressable/uri'
 require 'active_link_to/active_link_to'
-require 'active_link_to/version'
+require 'active_link_to/version'

data/lib/active_link_to/active_link_to.rb

@@ -7,8 +7,8 @@ module ActiveLinkTo
   #   :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)
+  #   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)
@@ -24,7 +24,7 @@ module ActiveLinkTo
     active_options  = { }
     link_options    = { }
     html_options.each do |k, v|
-      if [:active, :class_active, :class_inactive, :active_disable, :wrap_tag].member?(k)
+      if [:active, :class_active, :class_inactive, :active_disable, :wrap_tag, :wrap_class].member?(k)
         active_options[k] = v
       else
         link_options[k] = v
@@ -32,11 +32,20 @@ module ActiveLinkTo
     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
+    wrap_tag    = active_options[:wrap_tag].present? ? active_options[:wrap_tag] : nil
+    wrap_class  = active_options[:wrap_class].present? ? active_options[:wrap_class] + ' ' : ''
+
+    if wrap_tag.present?
+      wrap_class << active_link_to_class(url, active_options)
+      wrap_class.strip!
+    else
+      css_class << active_link_to_class(url, active_options)
+      css_class.strip!
+    end
+
     link_options[:class] = css_class if css_class.present?
+    link_options['aria-current'] = 'page' if is_active_link?(url, active_options[:active])
 
     link = if active_options[:active_disable] === true && is_active_link?(url, active_options[:active])
       content_tag(:span, name, link_options)
@@ -44,12 +53,12 @@ module ActiveLinkTo
       link_to(name, url, link_options)
     end
 
-    wrap_tag ? content_tag(wrap_tag, link, :class => (css_class if css_class.present?)) : link
+    wrap_tag ? content_tag(wrap_tag, link, class: (wrap_class if wrap_class.present?)) : 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')
+  #   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])
@@ -74,29 +83,36 @@ module ActiveLinkTo
   #   is_active_link?('/root', ['users', ['show', 'edit']])
   #
   def is_active_link?(url, condition = nil)
-    original_url = url
-    url = URI::parse(url).path
-    case condition
-    when :inclusive, nil
-      !request.fullpath.match(/^#{Regexp.escape(url).chomp('/')}(\/.*|\?.*)?$/).blank?
-    when :exclusive
-      !request.fullpath.match(/^#{Regexp.escape(url)}\/?(\?.*)?$/).blank?
-    when :exact
-      request.fullpath == original_url
-    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
-    when Hash
-      condition.all? do |key, value|
-        params[key].to_s == value.to_s
+    @is_active_link ||= {}
+    @is_active_link[[url, condition]] ||= begin
+      original_url = url
+      url = Addressable::URI::parse(url).path
+      path = request.original_fullpath
+      case condition
+      when :inclusive, nil
+        !path.match(/^#{Regexp.escape(url).chomp('/')}(\/.*|\?.*)?$/).blank?
+      when :exclusive
+        !path.match(/^#{Regexp.escape(url)}\/?(\?.*)?$/).blank?
+      when :exact
+        path == original_url
+      when Regexp
+        !path.match(condition).blank?
+      when Array
+        controllers = [*condition[0]]
+        actions     = [*condition[1]]
+        (controllers.blank? || controllers.member?(params[:controller])) &&
+        (actions.blank? || actions.member?(params[:action])) ||
+        controllers.any? do |controller, action|
+          params[:controller] == controller.to_s && params[:action] == action.to_s
+        end
+      when TrueClass
+        true
+      when FalseClass
+        false
+      when Hash
+        condition.all? do |key, value|
+          params[key].to_s == value.to_s
+        end
       end
     end
   end

data/lib/active_link_to/version.rb

@@ -1,3 +1,3 @@
 module ActiveLinkTo
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/test/active_link_to_test.rb

@@ -4,87 +4,87 @@ class ActiveLinkToTest < MiniTest::Test
 
   def test_is_active_link_booleans_test
     assert is_active_link?('/', true)
-    assert !is_active_link?('/', false)
+    refute is_active_link?('/', false)
   end
 
   def test_is_active_link_symbol_inclusive
-    request.fullpath = '/root'
+    set_path('/root')
     assert is_active_link?('/root', :inclusive)
 
-    request.fullpath = '/root?param=test'
+    set_path('/root?param=test')
     assert is_active_link?('/root', :inclusive)
 
-    request.fullpath = '/root/child/sub-child'
+    set_path('/root/child/sub-child')
     assert is_active_link?('/root', :inclusive)
 
-    request.fullpath = '/other'
-    assert !is_active_link?('/root', :inclusive)
+    set_path('/other')
+    refute is_active_link?('/root', :inclusive)
   end
 
   def test_is_active_link_symbol_inclusive_implied
-    request.fullpath = '/root/child/sub-child'
+    set_path('/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)
+    set_path('/root/abc')
+    refute is_active_link?('/root/a', :inclusive)
   end
 
   def test_is_active_link_symbol_inclusive_with_last_slash
-    request.fullpath = '/root/abc'
+    set_path('/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/')
+    set_path('/root_path')
+    refute is_active_link?('/root/')
   end
 
   def test_is_active_link_symbol_inclusive_with_link_params
-    request.fullpath = '/root?param=test'
+    set_path('/root?param=test')
     assert is_active_link?('/root?attr=example')
   end
 
   def test_is_active_link_symbol_exclusive
-    request.fullpath = '/root'
+    set_path('/root')
     assert is_active_link?('/root', :exclusive)
 
-    request.fullpath = '/root?param=test'
+    set_path('/root?param=test')
     assert is_active_link?('/root', :exclusive)
 
-    request.fullpath = '/root/child'
-    assert !is_active_link?('/root', :exclusive)
+    set_path('/root/child')
+    refute is_active_link?('/root', :exclusive)
   end
 
   def test_is_active_link_symbol_exclusive_with_link_params
-    request.fullpath = '/root?param=test'
+    set_path('/root?param=test')
     assert is_active_link?('/root?attr=example', :exclusive)
   end
 
   def test_is_active_link_symbol_exact
-    request.fullpath = '/root?param=test'
+    set_path('/root?param=test')
     assert is_active_link?('/root?param=test', :exact)
 
-    request.fullpath = '/root?param=test'
+    set_path('/root?param=test')
     refute is_active_link?('/root?param=exact', :exact)
 
-    request.fullpath = '/root'
+    set_path('/root')
     refute is_active_link?('/root?param=test', :exact)
 
-    request.fullpath = '/root?param=test'
+    set_path('/root?param=test')
     refute is_active_link?('/root', :exact)
   end
 
   def test_is_active_link_regex
-    request.fullpath = '/root'
+    set_path('/root')
     assert is_active_link?('/', /^\/root/)
 
-    request.fullpath = '/root/child'
+    set_path('/root/child')
     assert is_active_link?('/', /^\/r/)
 
-    request.fullpath = '/other'
-    assert !is_active_link?('/', /^\/r/)
+    set_path('/other')
+    refute is_active_link?('/', /^\/r/)
   end
 
   def test_is_active_link_array
@@ -98,39 +98,67 @@ class ActiveLinkToTest < MiniTest::Test
     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'])
+    refute is_active_link?('/', ['controller_a', 'action'])
+    refute is_active_link?('/', ['controller', 'action_a'])
+  end
+
+  def test_is_active_link_array_with_hash
+    params[:controller], params[:action] = 'controller', 'action'
+
+    assert is_active_link?('/', [controller: :action])
+    assert is_active_link?('/', ['controller' => 'action'])
+
+    refute is_active_link?('/', [controller_b: :action])
+    refute is_active_link?('/', [controller: :action_b])
+    refute is_active_link?('/', [controller_b: :action_b])
+
+    params[:controller], params[:action] = 'controller_b', 'action_b'
+
+    assert is_active_link?('/', [controller: :action, controller_b: :action_b])
   end
 
   def test_is_active_link_hash
     params[:a] = 1
 
-    assert is_active_link?('/', {:a => 1})
-    assert is_active_link?('/', {:a => 1, :b => nil})
+    assert is_active_link?('/', {a: 1})
+    assert is_active_link?('/', {a: 1, b: nil})
 
-    assert !is_active_link?('/', {:a => 1, :b => 2})
-    assert !is_active_link?('/', {:a => 2})
+    refute is_active_link?('/', {a: 1, b: 2})
+    refute is_active_link?('/', {a: 2})
 
     params[:b] = 2
 
-    assert is_active_link?('/', {:a => 1, :b => 2})
-    assert is_active_link?('/', {:a => 1, :b => 2, :c => nil})
+    assert is_active_link?('/', {a: 1, b: 2})
+    assert is_active_link?('/', {a: 1, b: 2, c: nil})
 
-    assert is_active_link?('/', {:a => 1})
-    assert is_active_link?('/', {:b => 2})
+    assert is_active_link?('/', {a: 1})
+    assert is_active_link?('/', {b: 2})
+  end
+
+  def test_is_active_link_with_anchor
+    set_path('/foo')
+    assert is_active_link?('/foo#anchor', :exclusive)
+  end
+
+  def test_is_active_link_with_memoization
+    set_path('/')
+    assert is_active_link?('/', :exclusive)
+
+    set_path('/other', false)
+    assert is_active_link?('/', :exclusive)
   end
 
   def test_active_link_to_class
-    request.fullpath = '/root'
+    set_path('/root')
     assert_equal 'active', active_link_to_class('/root')
-    assert_equal 'on', active_link_to_class('/root', :class_active => 'on')
+    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')
+    assert_equal 'off', active_link_to_class('/other', class_inactive: 'off')
   end
 
   def test_active_link_to
-    request.fullpath = '/root'
+    set_path('/root')
     link = active_link_to('label', '/root')
     assert_html link, 'a.active[href="/root"]', 'label'
 
@@ -139,61 +167,67 @@ class ActiveLinkToTest < MiniTest::Test
   end
 
   def test_active_link_to_with_existing_class
-    request.fullpath = '/root'
-    link = active_link_to('label', '/root', :class => 'current')
+    set_path('/root')
+    link = active_link_to('label', '/root', class: 'current')
     assert_html link, 'a.current.active[href="/root"]', 'label'
 
-    link = active_link_to('label', '/other', :class => 'current')
+    link = active_link_to('label', '/other', class: 'current')
     assert_html link, 'a.current[href="/other"]', 'label'
   end
 
   def test_active_link_to_with_custom_classes
-    request.fullpath = '/root'
-    link = active_link_to('label', '/root', :class_active => 'on')
+    set_path('/root')
+    link = active_link_to('label', '/root', class_active: 'on')
     assert_html link, 'a.on[href="/root"]', 'label'
 
-    link = active_link_to('label', '/other', :class_inactive => 'off')
+    link = active_link_to('label', '/other', class_inactive: 'off')
     assert_html link, 'a.off[href="/other"]', 'label'
   end
 
   def test_active_link_to_with_wrap_tag
-    request.fullpath = '/root'
-    link = active_link_to('label', '/root', :wrap_tag => :li)
-    assert_html link, 'li.active a.active[href="/root"]', 'label'
+    set_path('/root')
+    link = active_link_to('label', '/root', wrap_tag: :li)
+    assert_html link, 'li.active a[href="/root"]', 'label'
 
-    link = active_link_to('label', '/root', :wrap_tag => :li, :active_disable => true)
-    assert_html link, 'li.active span.active', 'label'
+    link = active_link_to('label', '/root', wrap_tag: :li, active_disable: true)
+    assert_html link, 'li.active span', 'label'
 
-    link = active_link_to('label', '/root', :wrap_tag => :li, :class => 'testing')
-    assert_html link, 'li.testing.active a.testing.active[href="/root"]', 'label'
+    link = active_link_to('label', '/root', wrap_tag: :li, class: 'testing')
+    assert_html link, 'li.active a.testing[href="/root"]', 'label'
   end
 
   def test_active_link_to_with_active_disable
-    request.fullpath = '/root'
-    link = active_link_to('label', '/root', :active_disable => true)
+    set_path('/root')
+    link = active_link_to('label', '/root', active_disable: true)
     assert_html link, 'span.active', 'label'
   end
 
   def test_should_not_modify_passed_params
-    request.fullpath = '/root'
-    params = { :class => 'testing', :active => :inclusive }
+    set_path('/root')
+    params = {class: 'testing', active: :inclusive}
     out = active_link_to 'label', '/root', params
     assert_html out, 'a.testing.active[href="/root"]', 'label'
-    assert_equal ({:class => 'testing', :active => :inclusive }), params
+    assert_equal ({class: 'testing', active: :inclusive }), params
   end
 
-  def test_no_empty_class_attribute
-    request.fullpath = '/root'
-    link = active_link_to('label', '/root', :wrap_tag => :li)
-    assert_html link, 'li.active a.active[href="/root"]', 'label'
+  def test_active_link_to_wrap_tag_class
+    set_path('/root')
+    link = active_link_to('label', '/root', wrap_tag: :li)
+    assert_html link, 'li.active a[href="/root"]', 'label'
 
-    link = active_link_to('label', '/other', :wrap_tag => :li)
+    link = active_link_to('label', '/other', wrap_tag: :li)
     assert_html link, 'li a[href="/other"]', 'label'
   end
 
-  def test_active_link_to_with_url
-    request.fullpath = '/root'
-    link = active_link_to('label', 'http://example.com/root')
-    assert_html link, 'a.active[href="http://example.com/root"]', 'label'
+  def test_active_link_to_with_aria
+    set_path('/root')
+    link = active_link_to('label', '/root')
+    assert_html link, 'a.active[href="/root"][aria-current="page"]', 'label'
+  end
+
+  def test_active_link_to_with_utf8
+    set_path('/äöü')
+    link = active_link_to('label', '/äöü')
+    assert_html link, 'a.active[href="/äöü"]', 'label'
   end
 end

data/test/test_helper.rb

@@ -1,38 +1,41 @@
-require 'rubygems'
+require 'bundler/setup'
 require 'minitest/autorun'
 require 'uri'
 require 'action_view'
-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'active_link_to'
 
-# need this to simulate requests that drive active_link_helper
-module FakeRequest
-  class Request
-    attr_accessor :fullpath
-  end
-  def request
-    @request ||= Request.new
-  end
-  def params
-    @params ||= {}
-  end
-end
+class MiniTest::Test
 
-ActiveLinkTo.send :include, FakeRequest
+  # need this to simulate requests that drive active_link_helper
+  module FakeRequest
+    class Request
+      attr_accessor :original_fullpath
+    end
+    def request
+      @request ||= Request.new
+    end
+    def params
+      @params ||= {}
+    end
+  end
 
-class MiniTest::Test
+  ActiveLinkTo.send :include, FakeRequest
 
   include ActionView::Helpers::UrlHelper
   include ActionView::Helpers::TagHelper
   include ActiveLinkTo
 
+  def set_path(path, purge_cache = true)
+    request.original_fullpath = path
+    if purge_cache && defined?(@is_active_link)
+      remove_instance_variable(:@is_active_link)
+    end
+  end
+
   def assert_html(html, selector, value = nil)
     doc = Nokogiri::HTML(html)
     element = doc.at_css(selector)
     assert element, "No element found at: `#{selector}`"
     assert_equal value, element.text if value
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_link_to
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Oleg Khabarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-20 00:00:00.000000000 Z
+date: 2017-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    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
@@ -63,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: ActionView helper to render currently active links