simple_active_link_to 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c2fc2f2a0baac9582848c238f5bbfb336d0829226b53f24fe50c3ed59e70ac5b
+  data.tar.gz: 197483dc1ed0902110ed3549379db959e300850548becdf3eecc8fd29d824a32
+SHA512:
+  metadata.gz: 481c153155351ffd7f0344d62e800913383d3fe58499baea5a016008d3ba1d49543148ab9a9040953d1ff92bc3bd988b7580a16c9dd4a5f1fa7824852368d470
+  data.tar.gz: 6442363c9c5a5f0c872886ab8eb24fcb4ab34db9950bfd604a08edc58a891dfe8d836d47b875ac31f7be89529e9befc56f287e2f4c601a808101373d54d233c6

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+rvm:
+  - 2.3.7
+  - 2.4.4
+  - 2.5.1
+  - ruby-head
+gemfile:
+  - test/gemfiles/5.0.gemfile
+  - test/gemfiles/5.1.gemfile
+  - test/gemfiles/5.2.gemfile
+before_install:
+  - gem update --system
+  - gem update bundler
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,10 @@
+source 'http://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'minitest'
+  gem 'rake'
+  gem 'rack-test'
+  gem 'nokogiri'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2009-17 Oleg Khabarov
+Copyright (c) 2020 Fajarullah
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,149 @@
+# simple_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), `simple_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/simple_active_link_to.svg?style=flat)](http://rubygems.org/gems/simple_active_link_to)
+[![Gem Downloads](https://img.shields.io/gem/dt/simple_active_link_to.svg?style=flat)](http://rubygems.org/gems/simple_active_link_to)
+[![Build Status](https://img.shields.io/travis/comfy/simple_active_link_to.svg?style=flat)](https://travis-ci.org/comfy/simple_active_link_to)
+[![Gitter](https://badges.gitter.im/comfy/comfortable-mexican-sofa.svg)](https://gitter.im/comfy/comfortable-mexican-sofa)
+
+support ruby >= 2.4
+
+## Installation
+add `gem 'simple_active_link_to'` to Gemfile and run `bundle install`.
+
+or using `bundle add` command
+
+`bundle add simple_active_link_to`
+
+For older Rails apps add `config.gem 'simple_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 a class attached if it happens to be rendered
+on page with path `/users` or any child of that page, like `/users/123`
+
+```ruby
+simple_active_link_to 'Users', '/users'
+# => <a href="/users" class="active">Users</a>
+```
+
+This is exactly the same as:
+
+```ruby
+simple_active_link_to 'Users', '/users', active: :inclusive
+# => <a href="/users" class="active">Users</a>
+```
+
+## Active Options
+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]]
+* 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 `simple_active_link_to` depends on the current
+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
+nodes. Most commonly used for 'home' links.
+
+```ruby
+# For URL: /users will be active
+simple_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
+simple_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':
+
+```ruby
+simple_active_link_to 'Users', users_path, active: /^\/use/
+```
+
+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
+simple_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,
+or action, or both? Or any number of those at the same time? Sure, why not:
+
+```ruby
+# For matching multiple controllers and actions:
+simple_active_link_to 'User Edit', edit_user_path(@user), active: [['people', 'news'], ['show', 'edit']]
+
+# For matching specific controllers and actions:
+simple_active_link_to 'User Edit', edit_user_path(@user), active: [people: :show, news: :edit]
+
+# for matching all actions under given controllers:
+simple_active_link_to 'User Edit', edit_user_path(@user), active: [['people', 'news'], []]
+
+# for matching all controllers for a particular action
+simple_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
+simple_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
+simple_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
+simple_active_link_to 'Users', users_path, class_active: 'enabled'
+# => <a href="/users" class="enabled">Users</a>
+
+simple_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
+simple_active_link_to 'Users', users_path, active_disable: true
+# => <span class="active">Users</span>
+```
+
+## Helper Methods
+You may directly use methods that `simple_active_link_to` relies on.
+
+`is_active_link?` will return true or false based on the URL and value of the `:active` parameter:
+
+```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'
+```
+
+### Copyright
+
+Copyright (c) 2009-18 Oleg Khabarov. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'rake/testtask'
+require 'bundler/setup'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task default: :test

data/lib/simple_active_link_to.rb

@@ -0,0 +1,3 @@
+require 'addressable/uri'
+require 'simple_active_link_to/simple_active_link_to'
+require 'simple_active_link_to/version'

data/lib/simple_active_link_to/simple_active_link_to.rb

@@ -0,0 +1,106 @@
+module SimpleActiveLinkTo
+  # 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:
+  #   simple_active_link_to('/users', class_active: 'enabled')
+  #   simple_active_link_to(users_path, active: :exclusive, wrap_tag: :li)
+  def simple_active_link_to(*args, &block)
+    name = block_given? ? capture(&block) : args.shift
+    options = args.shift || {}
+    html_options = args.shift || {}
+
+    url = url_for(options)
+
+    active_options = {}
+    link_options = {}
+    html_options.each do |k, v|
+      if %i[active class_active class_inactive active_disable].member?(k)
+        active_options[k] = v
+      else
+        link_options[k] = v
+      end
+    end
+
+    css_class = "#{link_options.delete(:class)} #{active_link_to_class(url, active_options)}"
+    css_class.strip!
+    link_options[:class] = css_class if css_class != ''
+
+    is_active = is_active_link?(url, active_options[:active])
+    link_options[:'aria-current'] = 'page' if is_active
+
+    if active_options[:active_disable] == true && is_active
+      content_tag(:span, name, link_options)
+    else
+      link_to(name, url, link_options)
+    end
+  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)
+    @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?(%r{^#{Regexp.escape(url).chomp('/')}(/.*|\?.*)?$})
+      when :exclusive
+        path.match?(%r{^#{Regexp.escape(url)}/?(\?.*)?$})
+      when :exact
+        path == original_url
+      when Regexp
+        path.match?(condition)
+      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
+end
+
+ActiveSupport.on_load :action_view do
+  include SimpleActiveLinkTo
+end

data/lib/simple_active_link_to/version.rb

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

data/simple_active_link_to.gemspec

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'simple_active_link_to/version'
+
+Gem::Specification.new do |s|
+  s.name          = "simple_active_link_to"
+  s.version       = SimpleActiveLinkTo::VERSION
+  s.authors       = ["Fajarullah"]
+  s.email         = ["frullah12@gmail.com"]
+  s.homepage      = "http://github.com/frullah/simple_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.license       = "MIT"
+
+  s.files         = `git ls-files`.split("\n")
+
+  s.required_ruby_version = ">= 2.4.0"
+
+  s.add_dependency 'actionpack'
+  s.add_dependency 'addressable'
+end

data/test/gemfiles/5.0.gemfile

@@ -0,0 +1,12 @@
+source 'http://rubygems.org'
+
+gemspec path: "../../"
+
+gem "actionpack", "~> 5.0.0"
+
+group :test do
+  gem 'minitest'
+  gem 'rake'
+  gem 'rack-test'
+  gem 'nokogiri'
+end

data/test/gemfiles/5.1.gemfile

@@ -0,0 +1,12 @@
+source 'http://rubygems.org'
+
+gemspec path: "../../"
+
+gem "actionpack", "~> 5.1.0"
+
+group :test do
+  gem 'minitest'
+  gem 'rake'
+  gem 'rack-test'
+  gem 'nokogiri'
+end

data/test/gemfiles/5.2.gemfile

@@ -0,0 +1,12 @@
+source 'http://rubygems.org'
+
+gemspec path: "../../"
+
+gem "actionpack", "~> 5.2.0"
+
+group :test do
+  gem 'minitest'
+  gem 'rake'
+  gem 'rack-test'
+  gem 'nokogiri'
+end

data/test/simple_active_link_to_test.rb

@@ -0,0 +1,212 @@
+require_relative 'test_helper'
+
+class SimpleActiveLinkToTest < 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 = simple_active_link_to('label', '/root')
+    assert_html link, 'a.active[href="/root"]', 'label'
+
+    link = simple_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 = simple_active_link_to('label', '/root', class: 'current')
+    assert_html link, 'a.current.active[href="/root"]', 'label'
+
+    link = simple_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 = simple_active_link_to('label', '/root', class_active: 'on')
+    assert_html link, 'a.on[href="/root"]', 'label'
+
+    link = simple_active_link_to('label', '/other', class_inactive: 'off')
+    assert_html link, 'a.off[href="/other"]', 'label'
+  end
+
+  def test_active_link_to_with_active_disable
+    set_path('/root')
+    link = simple_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 = simple_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_with_aria
+    set_path('/root')
+    link = simple_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 = simple_active_link_to('label', '/äöü')
+    assert_html link, 'a.active[href="/äöü"]', 'label'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,41 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'uri'
+require 'action_view'
+require 'simple_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
+
+  SimpleActiveLinkTo.send :include, FakeRequest
+
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include SimpleActiveLinkTo
+
+  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

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: simple_active_link_to
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Fajarullah
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  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'
+- !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
+email:
+- frullah12@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/simple_active_link_to.rb
+- lib/simple_active_link_to/simple_active_link_to.rb
+- lib/simple_active_link_to/version.rb
+- simple_active_link_to-1.0.0.gem
+- simple_active_link_to.gemspec
+- test/gemfiles/5.0.gemfile
+- test/gemfiles/5.1.gemfile
+- test/gemfiles/5.2.gemfile
+- test/simple_active_link_to_test.rb
+- test/test_helper.rb
+homepage: http://github.com/frullah/simple_active_link_to
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: ActionView helper to render currently active links
+test_files: []