active_link_to 1.0.5 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d0d98b57bf4abf67586e2eb4121f6fdd0b435b2e
-  data.tar.gz: 7c59ffc37c74c76e97fa7d0d67918f2a91e6ecea
+SHA256:
+  metadata.gz: 23739b476611e406b4da34c0597867fa72eaf5e218d736732a44b2acfc9bf425
+  data.tar.gz: 3edfd60e459ba7b00ea7943cada4db37ac4c94ba23c91768098d62770ed19a2a
 SHA512:
-  metadata.gz: bd29e30982524b635daba3fdfd64df45d4bc91c000d3c5946d00cde1732a2a791e548d74b6b204935aebad5c4d06150e42faa0eb40e4a19ee381dd8b30205fe4
-  data.tar.gz: 432188f6449e92a6fa822d8feecb516ee47afee975243fd66de33f57eb4245de934ed942ecf3d062a6680f6c0450d15c30a410bcd86173b343aec9575d53f364
+  metadata.gz: 90a5df4d63147bc0e26757709e00ac5aeb8a51692709a9666948dcfb773bcdf4874f8711a0df9f9ac05760101ad2a4bed34d30c26ff239c99496f13100a8262c
+  data.tar.gz: 19d95a895f0bd464afcd0ca91693c99903cf9db248d79b58043e1e5ac8beac79d6a7a4965d38b3800b8ca10902f3f21ab37d8744772539c37863509263f07a9f

data/.github/workflows/build.yml

@@ -0,0 +1,33 @@
+name: build
+on:
+  pull_request:
+  push:
+    branches: [master]
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "4.0"
+          bundler-cache: true
+      - run: bundle exec rubocop
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - ruby: "4.0"
+            gemfile: Gemfile
+    env:
+      BUNDLE_GEMFILE: ${{ matrix.gemfile }}
+    steps:
+      - uses: actions/checkout@v7
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rspec

data/.gitignore

@@ -1,2 +1,3 @@
 .DS_Store
+pkg/
 Gemfile.lock

data/.rubocop.yml

@@ -0,0 +1,17 @@
+AllCops:
+  NewCops: enable
+  SuggestExtensions: false
+
+# Everything is too big and too complex, yes.
+Metrics:
+  Enabled: false
+
+# is_active_link? not getting renamed
+Naming/PredicatePrefix:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false

data/Gemfile

@@ -1,10 +1,10 @@
-source 'http://rubygems.org'
+# frozen_string_literal: true
+
+source "http://rubygems.org"
 
 gemspec
 
-group :test do
-  gem 'minitest'
-  gem 'rake'
-  gem 'rack-test'
-  gem 'nokogiri'
-end
+gem "rake"
+gem "rspec", "~> 3.0"
+gem "rspec-html-matchers", "~> 0.10"
+gem "rubocop", "~> 1.92"

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009-17 Oleg Khabarov
+Copyright (c) 2009-26 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

@@ -1,12 +1,19 @@
 # active_link_to
-[![Gem Version](https://img.shields.io/gem/v/active_link_to.svg?style=flat)](http://rubygems.org/gems/active_link_to) [![Gem Downloads](https://img.shields.io/gem/dt/active_link_to.svg?style=flat)](http://rubygems.org/gems/active_link_to) [![Build Status](https://img.shields.io/travis/comfy/active_link_to.svg?style=flat)](https://travis-ci.org/comfy/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](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'.
 
+[![Gem Version](https://img.shields.io/gem/v/active_link_to.svg?style=flat)](http://rubygems.org/gems/active_link_to)
+[![Gem Downloads](https://img.shields.io/gem/dt/active_link_to.svg?style=flat)](http://rubygems.org/gems/active_link_to)
+
 ## 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.
+Add to your Gemfile:
+
+```ruby
+gem "active_link_to"
+```
+
+and then run `bundle install`
 
 ## Super Simple Example
 Here's a link that will have a class attached if it happens to be rendered
@@ -36,6 +43,28 @@ Here's a list of available options that can be used as the `:active` value
 * Hash                            -> { param_a: 1, param_b: 2 }
 ```
 
+## Configuration
+Several of the options that can be set in a calling of the helper can also be set in an
+initializer. For example, if you want to use `is-active` as the active class all the time,
+create `config/initializers/active_link_to.rb` with:
+
+```ruby
+ActiveLinkTo.configure do |config|
+  config.class_active = 'is-active'
+end
+```
+
+The full list of configurable values is:
+
+- `class_active` with default `"active"`
+- `class_inactive` with default `""`
+- `active_disable` with default `false`
+- `wrap_tag` with default `nil`
+- `wrap_class` with default `""`
+
+Setting these values in configuration just changes the default -- setting them in a
+use of the helper should always override the default, as you'd expect.
+
 ## More Examples
 Most of the functionality of `active_link_to` depends on the current
 url. Specifically, `request.original_fullpath` value. We covered the basic example
@@ -150,4 +179,4 @@ active_link_to_class(users_path, active: :inclusive)
 
 ### Copyright
 
-Copyright (c) 2009-17 Oleg Khabarov. See LICENSE for details.
+Copyright (c) 2009-26 Oleg Khabarov. See LICENSE for details.

data/Rakefile

@@ -1,11 +1,10 @@
-require 'rubygems'
-require 'rake/testtask'
-require 'bundler/setup'
+# frozen_string_literal: true
 
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
-end
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+require "rspec/core/rake_task"
 
-task default: :test
+RuboCop::RakeTask.new(:rubocop)
+RSpec::Core::RakeTask.new(:spec)
+
+task default: %i[rubocop spec]

data/active_link_to.gemspec

@@ -1,7 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-$:.unshift File.expand_path('../lib', __FILE__)
-require 'active_link_to/version'
+$LOAD_PATH.unshift File.expand_path("lib", __dir__)
+require "active_link_to/version"
 
 Gem::Specification.new do |s|
   s.name          = "active_link_to"
@@ -10,12 +10,17 @@ Gem::Specification.new do |s|
   s.email         = ["oleg@khabarov.ca"]
   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.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.license       = "MIT"
 
   s.files         = `git ls-files`.split("\n")
-  s.platform      = Gem::Platform::RUBY
-  s.require_paths = ['lib']
 
-  s.add_dependency 'actionpack'
-  s.add_dependency 'addressable'
+  s.required_ruby_version = ">= 2.3.0"
+
+  s.add_dependency "actionpack"
+  s.add_dependency "addressable"
+
+  s.metadata["rubygems_mfa_required"] = "true"
 end

data/lib/active_link_to/active_link_to.rb

@@ -1,52 +1,73 @@
-module ActiveLinkTo
+# frozen_string_literal: true
 
-  # 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)
+# Wrapper around link_to. Accepts following params:
+#   :active         => Boolean | Symbol | Regex | Controller/Action Pair
+#   :class_active   => String
+#   :class_inactive => String
+#   :active_disable => Boolean
+#   :wrap_tag       => Symbol
+# Example usage:
+#   active_link_to('/users', class_active: 'enabled')
+#   active_link_to(users_path, active: :exclusive, wrap_tag: :li)
+#
+module ActiveLinkTo
   def active_link_to(*args, &block)
-    name = block_given? ? capture(&block) : args.shift
-    options = args.shift || {}
+    name         = block_given? ? capture(&block) : args.shift
+    options      = args.shift || {}
     html_options = args.shift || {}
-    
+
     url = url_for(options)
 
-    active_options  = { }
-    link_options    = { }
+    active_options  = {}
+    link_options    = {}
     html_options.each do |k, v|
-      if [:active, :class_active, :class_inactive, :active_disable, :wrap_tag, :wrap_class].member?(k)
+      if %i[active class_active class_inactive active_disable wrap_tag wrap_class].member?(k)
         active_options[k] = v
       else
         link_options[k] = v
       end
     end
 
-    css_class = link_options.delete(:class).to_s + ' '
+    css_class = link_options.delete(:class).to_s
 
-    wrap_tag    = active_options[:wrap_tag].present? ? active_options[:wrap_tag] : nil
-    wrap_class  = active_options[:wrap_class].present? ? active_options[:wrap_class] + ' ' : ''
+    wrap_tag =
+      if active_options.member?(:wrap_tag)
+        active_options[:wrap_tag]
+      else
+        ActiveLinkTo.configuration.wrap_tag
+      end
+
+    wrap_class =
+      if active_options.member?(:wrap_class)
+        active_options[:wrap_class]
+      else
+        ActiveLinkTo.configuration.wrap_class
+      end
 
     if wrap_tag.present?
-      wrap_class << active_link_to_class(url, active_options)
+      wrap_class = "#{wrap_class} #{active_link_to_class(url, active_options)}"
       wrap_class.strip!
     else
-      css_class << active_link_to_class(url, active_options)
+      css_class = "#{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_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)
-    else
-      link_to(name, url, link_options)
-    end
+    should_disable_link =
+      if active_options.member?(:active_disable)
+        active_options[:active_disable]
+      else
+        ActiveLinkTo.configuration.active_disable
+      end
+
+    link =
+      if should_disable_link && 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: (wrap_class if wrap_class.present?)) : link
   end
@@ -57,9 +78,9 @@ module ActiveLinkTo
   #
   def active_link_to_class(url, options = {})
     if is_active_link?(url, options[:active])
-      options[:class_active] || 'active'
+      options[:class_active] || ActiveLinkTo.configuration.class_active
     else
-      options[:class_inactive] || ''
+      options[:class_inactive] || ActiveLinkTo.configuration.class_inactive
     end
   end
 
@@ -78,32 +99,48 @@ module ActiveLinkTo
   #   is_active_link?('/root', ['users', ['show', 'edit']])
   #
   def is_active_link?(url, condition = nil)
+    return false if request.nil?
+
     @is_active_link ||= {}
     @is_active_link[[url, condition]] ||= begin
       original_url = url
-      url = Addressable::URI::parse(url).path
-      path = request.original_fullpath
+      url          = Addressable::URI.parse(url).path
+      path         = request.original_fullpath
+
       case condition
       when :inclusive, nil
-        !path.match(/^#{Regexp.escape(url).chomp('/')}(\/.*|\?.*)?$/).blank?
+        !path.match(%r{^#{Regexp.escape(url).chomp('/')}(/.*|\?.*)?$}).blank?
+
       when :exclusive
-        !path.match(/^#{Regexp.escape(url)}\/?(\?.*)?$/).blank?
+        !path.match(%r{^#{Regexp.escape(url)}/?(\?.*)?$}).blank?
+
       when :exact
         path == original_url
+
       when Regexp
         !path.match(condition).blank?
+
+      # This may come in two forms:
+      #   - tuple with first item being controller names followed by names of actions
+      #   - array of hashes where key is list of controllers and value is a list of actions
       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
+        pairs =
+          if condition.all?(Hash)
+            condition[0]
+          else
+            { condition[0] => condition[1] }
+          end
+
+        pairs.any? do |controllers, actions|
+          [*controllers].map(&:to_s).include?(params[:controller]) && [*actions].map(&:to_s).include?(params[:action])
         end
+
       when TrueClass
         true
+
       when FalseClass
         false
+
       when Hash
         condition.all? do |key, value|
           params[key].to_s == value.to_s

data/lib/active_link_to/configuration.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Instead of explicitly passing options to the active_link_to, you can create
+# an initializer like `config/initializers/active_link_to.rb` with:
+#
+#   ActiveLinkTo.configure do |config|
+#     config.class_active = "is-active"
+#   end
+#
+module ActiveLinkTo
+  class Configuration
+    attr_accessor :class_active, :class_inactive, :active_disable, :wrap_tag, :wrap_class
+
+    def initialize
+      @class_active   = "active"
+      @class_inactive = ""
+      @active_disable = false
+      @wrap_tag       = nil
+      @wrap_class     = ""
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  def self.configure
+    yield configuration
+  end
+end

data/lib/active_link_to/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveLinkTo
-  VERSION = "1.0.5"
-end
+  VERSION = "1.1.0"
+end

data/lib/active_link_to.rb

@@ -1,3 +1,6 @@
-require 'addressable/uri'
-require 'active_link_to/active_link_to'
-require 'active_link_to/version'
+# frozen_string_literal: true
+
+require "addressable/uri"
+require "active_link_to/active_link_to"
+require "active_link_to/configuration"
+require "active_link_to/version"

data/spec/active_link_to_spec.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe ActiveLinkTo do
+  describe "#is_active_link?" do
+    it "works for the boolean flag" do
+      expect(is_active_link?("/any-path", true)).to be(true)
+      expect(is_active_link?("/any-path", false)).to be(false)
+    end
+
+    it "works for the :inclusive flag" do
+      current_path_is("/foo")
+      expect(is_active_link?("/foo", :inclusive)).to be(true)
+
+      current_path_is("/foo?param=bar")
+      expect(is_active_link?("/foo", :inclusive)).to be(true)
+
+      current_path_is("/foo/child/sub-child")
+      expect(is_active_link?("/foo", :inclusive)).to be(true)
+
+      current_path_is("/bar")
+      expect(is_active_link?("/foo", :inclusive)).to be(false)
+    end
+
+    it "works without value as :inclusive flag is implied" do
+      current_path_is("/foo/bar")
+      expect(is_active_link?("/foo")).to be(true)
+      expect(is_active_link?("/bar")).to be(false)
+    end
+
+    it "doesn't match on a partial path value" do
+      current_path_is("/foo/bar")
+      expect(is_active_link?("/foo/ba")).to be(false)
+    end
+
+    it "works when path value specifies ending slash" do
+      current_path_is("/foo/bar")
+      expect(is_active_link?("/foo/")).to be(true)
+    end
+
+    it "doesn't match if path value is partial with ending slash" do
+      current_path_is("/foo_bar")
+      expect(is_active_link?("/foo/")).to be(false)
+    end
+
+    it "matches on path with dissimilar params" do
+      current_path_is("/foo?param=bar")
+      expect(is_active_link?("/foo?attr=something-else")).to be(true)
+    end
+
+    it "works for the :exclusive flag" do
+      current_path_is("/foo")
+      expect(is_active_link?("/foo", :exclusive)).to be(true)
+
+      current_path_is("/foo?param=bar")
+      expect(is_active_link?("/foo", :exclusive)).to be(true)
+
+      current_path_is("/foo/bar")
+      expect(is_active_link?("/foo", :exclusive)).to be(false)
+    end
+
+    it "matches path with dissimilar params for the :exclusive flag" do
+      current_path_is("/foo?param=bar")
+      expect(is_active_link?("/foo?attr=example", :exclusive)).to be(true)
+    end
+
+    it "works for the :exact flag" do
+      current_path_is("/foo?param=bar")
+
+      expect(is_active_link?("/foo?param=bar", :exact)).to be(true)
+      expect(is_active_link?("/foo?param=other", :exact)).to be(false)
+      expect(is_active_link?("/foo", :exact)).to be(false)
+
+      current_path_is("/foo")
+      expect(is_active_link?("/foo?param=bar", :exact)).to be(false)
+    end
+
+    it "works for the regex flag" do
+      current_path_is("/foo")
+      expect(is_active_link?("/", %r{^/foo})).to be(true)
+
+      current_path_is("/foo/bar")
+      expect(is_active_link?("/", %r{^/fo})).to be(true)
+
+      current_path_is("/bar")
+      expect(is_active_link?("/", %r{^/fo})).to be(false)
+    end
+
+    it "works for an array of controller and action names as a flag" do
+      # currently active controller/action pair
+      params[:controller] = "foos"
+      params[:action]     = "bar"
+
+      expect(is_active_link?("/", [["foos"], ["bar"]])).to be(true)
+      expect(is_active_link?("/", [["foos"], %w[bar baz]])).to be(true)
+      expect(is_active_link?("/", [%w[foos bars], ["bar"]])).to be(true)
+      expect(is_active_link?("/", [%w[foos bars], %w[bar baz]])).to be(true)
+      expect(is_active_link?("/", [%i[foos bars], %i[bar baz]])).to be(true)
+
+      expect(is_active_link?("/", %w[foos bar])).to be(true)
+      expect(is_active_link?("/", ["foos", %w[bar baz]])).to be(true)
+      expect(is_active_link?("/", [%w[foos bars], "bar"])).to be(true)
+
+      expect(is_active_link?("/", %w[others bar])).to be(false)
+      expect(is_active_link?("/", %w[foos other])).to be(false)
+    end
+
+    it "works when flag is defined as a hash" do
+      # currently active controller/action pair
+      params[:controller] = "foos"
+      params[:action]     = "bar"
+
+      expect(is_active_link?("/", [{ foos: :bar }])).to be(true)
+      expect(is_active_link?("/", [{ "foos" => "bar" }])).to be(true)
+      expect(is_active_link?("/", [{ %i[foos bars] => %w[foo bar], %w[eggs hams] => %i[egg bar] }])).to be(true)
+
+      expect(is_active_link?("/", [{ foos: :foo, bars: :bar }])).to be(false)
+    end
+
+    it "works for parameter matching" do
+      params[:a] = 1
+
+      expect(is_active_link?("/", { a: 1 })).to be(true)
+      expect(is_active_link?("/", { a: 1, b: nil })).to be(true)
+
+      expect(is_active_link?("/", { a: 1, b: 2 })).to be(false)
+      expect(is_active_link?("/", { a: 2 })).to be(false)
+
+      params[:b] = 2
+
+      expect(is_active_link?("/", { a: 1, b: 2 })).to be(true)
+      expect(is_active_link?("/", { a: 1, b: 2, c: nil })).to be(true)
+
+      expect(is_active_link?("/", { a: 1 })).to be(true)
+      expect(is_active_link?("/", { b: 2 })).to be(true)
+    end
+
+    it "matches if path value has anchor" do
+      current_path_is("/foo")
+
+      expect(is_active_link?("/foo#anchor", :exclusive)).to be(true)
+    end
+
+    it "returns false if request is nil (like in email templates)" do
+      allow(self).to receive(:request).and_return(nil)
+      expect(is_active_link?("/foo")).to be(false)
+    end
+  end
+
+  describe "#active_link_to_class" do
+    it "returns css class name for active links" do
+      current_path_is("/foo")
+
+      expect(active_link_to_class("/foo")).to eq("active")
+      expect(active_link_to_class("/other")).to eq("")
+    end
+
+    it "can use custom css class names for active and inactive links" do
+      current_path_is("/foo")
+
+      expect(active_link_to_class("/foo", class_active: "on")).to eq("on")
+      expect(active_link_to_class("/other", class_inactive: "off")).to eq("off")
+    end
+  end
+
+  describe "#active_link_to" do
+    it "renders link with active state" do
+      current_path_is("/foo")
+
+      link = active_link_to("label", "/foo")
+      expect(link).to have_tag("a", with: { href: "/foo", class: "active" }, text: "label")
+
+      link = active_link_to("label", "/other")
+      expect(link).to have_tag("a", without: { class: "active" })
+    end
+
+    it "doesn't clobber existing class names" do
+      current_path_is("/foo")
+
+      link = active_link_to("label", "/foo", class: "existing")
+      expect(link).to have_tag("a", with: { class: %w[active existing] })
+    end
+
+    it "works with custom active and inactive class names" do
+      current_path_is("/foo")
+
+      active_link = active_link_to("label", "/foo", class_active: "on")
+      expect(active_link).to have_tag("a", with: { class: "on" })
+
+      inactive_link = active_link_to("label", "/bar", class_inactive: "off")
+      expect(inactive_link).to have_tag("a", with: { class: "off" })
+    end
+
+    it "can render span instead of an active link" do
+      current_path_is("/foo")
+
+      active_link = active_link_to("label", "/foo", active_disable: true)
+      expect(active_link).to have_tag("span", with: { class: "active" }, text: "label")
+
+      inactive_link = active_link_to("label", "/bar", active_disable: true)
+      expect(inactive_link).to have_tag("a", without: { class: "active" }, text: "label")
+    end
+
+    it "can use wrapper element around active link" do
+      current_path_is("/foo")
+
+      link = active_link_to("label", "/foo", wrap_tag: :li, wrap_class: "wrap-class", class: "existing")
+      expect(link).to have_tag("li", with: { class: %w[wrap-class active] }) do
+        with_tag("a", without: { class: "active" }, with: { class: "existing" })
+      end
+    end
+
+    it "should not modify passed-in params" do
+      current_path_is("/foo")
+      params = { class: "testing", active: :inclusive }
+
+      link = active_link_to "label", "/foo", params
+      expect(link).to have_tag("a", with: { href: "/foo", class: %w[active testing] }, text: "label")
+      expect(params).to eq({ class: "testing", active: :inclusive })
+    end
+
+    it "marks active link with aria attribute" do
+      current_path_is("/foo")
+
+      active_link = active_link_to("label", "/foo")
+      expect(active_link).to have_tag("a", with: { "aria-current": "page", class: "active" })
+
+      inactive_link = active_link_to("label", "/bar")
+      expect(inactive_link).to have_tag("a", without: { "aria-current": "page", class: "active" })
+    end
+
+    it "renders link with utf8 characters" do
+      current_path_is("/äöü")
+
+      link = active_link_to("label", "/äöü")
+      expect(link).to have_tag("a", with: { href: "/äöü", class: "active" })
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe ActiveLinkTo::Configuration do
+  let(:config) { ActiveLinkTo::Configuration.new }
+
+  after do
+    ActiveLinkTo.configuration = ActiveLinkTo::Configuration.new
+  end
+
+  describe "#class_active" do
+    it "has default value" do
+      expect(config.class_active).to eq("active")
+    end
+
+    it "uses configured value" do
+      ActiveLinkTo.configuration.class_active = "custom-active"
+      current_path_is("/foo")
+
+      active_link = active_link_to("label", "/foo")
+      expect(active_link).to have_tag("a", with: { class: "custom-active" })
+    end
+
+    it "uses explicit value" do
+      ActiveLinkTo.configuration.class_active = "custom-active"
+      current_path_is("/foo")
+
+      active_link = active_link_to("label", "/foo", class_active: "explicit-active")
+      expect(active_link).to have_tag("a", with: { class: "explicit-active" })
+    end
+  end
+
+  describe "#class_inactive" do
+    it "has default value" do
+      expect(config.class_inactive).to eq("")
+    end
+
+    it "uses configured value" do
+      ActiveLinkTo.configuration.class_inactive = "custom-inactive"
+      current_path_is("/foo")
+
+      active_link = active_link_to("label", "/bar")
+      expect(active_link).to have_tag("a", with: { class: "custom-inactive" })
+    end
+
+    it "uses explicit value" do
+      ActiveLinkTo.configuration.class_inactive = "custom-active"
+      current_path_is("/foo")
+
+      active_link = active_link_to("label", "/bar", class_inactive: "explicit-inactive")
+      expect(active_link).to have_tag("a", with: { class: "explicit-inactive" })
+    end
+  end
+
+  describe "#active_disable" do
+    it "has default value" do
+      expect(config.active_disable).to eq(false)
+    end
+
+    it "uses configured value" do
+      ActiveLinkTo.configuration.active_disable = true
+      current_path_is("/foo")
+
+      active_link = active_link_to("label", "/foo")
+      expect(active_link).to have_tag("span", with: { class: "active" }, text: "label")
+    end
+
+    it "uses explicit value" do
+      ActiveLinkTo.configuration.active_disable = true
+      current_path_is("/foo")
+
+      active_link = active_link_to("label", "/foo", active_disable: false)
+      expect(active_link).to have_tag("a", with: { href: "/foo", class: "active" }, text: "label")
+    end
+  end
+
+  describe "#wrap_tag" do
+    it "has default value" do
+      expect(config.wrap_tag).to eq(nil)
+    end
+
+    it "uses configured value" do
+      ActiveLinkTo.configuration.wrap_tag = "configured-tag"
+      current_path_is("/foo")
+
+      link = active_link_to("label", "/foo")
+      expect(link).to have_tag("configured-tag", with: { class: "active" }) do
+        with_tag("a")
+      end
+    end
+
+    it "uses explicit value" do
+      ActiveLinkTo.configuration.wrap_tag = "configured-tag"
+      current_path_is("/foo")
+
+      link = active_link_to("label", "/foo", wrap_tag: "explicit-tag")
+      expect(link).to have_tag("explicit-tag", with: { class: "active" }) do
+        with_tag("a")
+      end
+
+      link = active_link_to("label", "/foo", wrap_tag: nil)
+      expect(link).to have_tag("a", with: { class: "active" })
+    end
+  end
+
+  describe "#wrap_class" do
+    it "has default value" do
+      expect(config.wrap_class).to eq("")
+    end
+
+    it "uses configured value" do
+      ActiveLinkTo.configuration.wrap_tag   = "configured-tag"
+      ActiveLinkTo.configuration.wrap_class = "configured-class"
+      current_path_is("/foo")
+
+      link = active_link_to("label", "/foo")
+      expect(link).to have_tag("configured-tag", with: { class: %w[configured-class active] }) do
+        with_tag("a")
+      end
+    end
+
+    it "uses explicit value" do
+      ActiveLinkTo.configuration.wrap_tag   = "configured-tag"
+      ActiveLinkTo.configuration.wrap_class = "configured-class"
+      current_path_is("/foo")
+
+      link = active_link_to("label", "/foo", wrap_class: "explicit-class")
+      expect(link).to have_tag("configured-tag", with: { class: %w[explicit-class active] }) do
+        with_tag("a")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+Bundler.setup
+
+require "rspec-html-matchers"
+
+require "action_view"
+require "active_link_to"
+
+# Fake request object that is used in our tests
+module FakeRequest
+  class Request
+    attr_accessor :original_fullpath
+  end
+
+  def request
+    @request ||= Request.new
+  end
+
+  def params
+    @params ||= {}
+  end
+
+  def current_path_is(path, purge_cache: true)
+    request.original_fullpath = path
+
+    # method is cached, so we bust it to set path multiple times in one test
+    return unless purge_cache && defined?(@is_active_link)
+
+    remove_instance_variable(:@is_active_link)
+  end
+end
+
+ActiveLinkTo.include FakeRequest
+
+RSpec.configure do |config|
+  config.include ActionView::Helpers::UrlHelper
+  config.include ActionView::Helpers::TagHelper
+  config.include RSpecHtmlMatchers
+  config.include ActiveLinkTo
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_link_to
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0
 platform: ruby
 authors:
 - Oleg Khabarov
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -47,7 +46,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/build.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -55,13 +56,16 @@ files:
 - active_link_to.gemspec
 - lib/active_link_to.rb
 - lib/active_link_to/active_link_to.rb
+- lib/active_link_to/configuration.rb
 - lib/active_link_to/version.rb
-- test/active_link_to_test.rb
-- test/test_helper.rb
+- spec/active_link_to_spec.rb
+- spec/configuration_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/comfy/active_link_to
-licenses: []
-metadata: {}
-post_install_message: 
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -69,16 +73,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
-signing_key: 
+rubygems_version: 4.0.9
 specification_version: 4
 summary: ActionView helper to render currently active links
 test_files: []

data/test/active_link_to_test.rb

@@ -1,233 +0,0 @@
-require_relative 'test_helper'
-
-class ActiveLinkToTest < MiniTest::Test
-
-  def test_is_active_link_booleans_test
-    assert is_active_link?('/', true)
-    refute is_active_link?('/', false)
-  end
-
-  def test_is_active_link_symbol_inclusive
-    set_path('/root')
-    assert is_active_link?('/root', :inclusive)
-
-    set_path('/root?param=test')
-    assert is_active_link?('/root', :inclusive)
-
-    set_path('/root/child/sub-child')
-    assert is_active_link?('/root', :inclusive)
-
-    set_path('/other')
-    refute is_active_link?('/root', :inclusive)
-  end
-
-  def test_is_active_link_symbol_inclusive_implied
-    set_path('/root/child/sub-child')
-    assert is_active_link?('/root')
-  end
-
-  def test_is_active_link_symbol_inclusive_similar_path
-    set_path('/root/abc')
-    refute is_active_link?('/root/a', :inclusive)
-  end
-
-  def test_is_active_link_symbol_inclusive_with_last_slash
-    set_path('/root/abc')
-    assert is_active_link?('/root/')
-  end
-
-  def test_is_active_link_symbol_inclusive_with_last_slash_and_similar_path
-    set_path('/root_path')
-    refute is_active_link?('/root/')
-  end
-
-  def test_is_active_link_symbol_inclusive_with_link_params
-    set_path('/root?param=test')
-    assert is_active_link?('/root?attr=example')
-  end
-
-  def test_is_active_link_symbol_exclusive
-    set_path('/root')
-    assert is_active_link?('/root', :exclusive)
-
-    set_path('/root?param=test')
-    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
-    set_path('/root?param=test')
-    assert is_active_link?('/root?attr=example', :exclusive)
-  end
-
-  def test_is_active_link_symbol_exact
-    set_path('/root?param=test')
-    assert is_active_link?('/root?param=test', :exact)
-
-    set_path('/root?param=test')
-    refute is_active_link?('/root?param=exact', :exact)
-
-    set_path('/root')
-    refute is_active_link?('/root?param=test', :exact)
-
-    set_path('/root?param=test')
-    refute is_active_link?('/root', :exact)
-  end
-
-  def test_is_active_link_regex
-    set_path('/root')
-    assert is_active_link?('/', /^\/root/)
-
-    set_path('/root/child')
-    assert is_active_link?('/', /^\/r/)
-
-    set_path('/other')
-    refute 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'])
-
-    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})
-
-    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})
-    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
-    set_path('/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
-    set_path('/root')
-    link = active_link_to('label', '/root')
-    assert_html link, 'a.active[href="/root"]', 'label'
-
-    link = active_link_to('label', '/other')
-    assert_html link, 'a[href="/other"]', 'label'
-  end
-
-  def test_active_link_to_with_existing_class
-    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')
-    assert_html link, 'a.current[href="/other"]', 'label'
-  end
-
-  def test_active_link_to_with_custom_classes
-    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')
-    assert_html link, 'a.off[href="/other"]', 'label'
-  end
-
-  def test_active_link_to_with_wrap_tag
-    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', '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
-    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
-    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
-  end
-
-  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)
-    assert_html link, 'li a[href="/other"]', 'label'
-  end
-
-  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,41 +0,0 @@
-require 'bundler/setup'
-require 'minitest/autorun'
-require 'uri'
-require 'action_view'
-require 'active_link_to'
-
-class MiniTest::Test
-
-  # 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
-
-  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