grape-route-helpers 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70edfbe7fe2afd10d2030ffbfec49dc642f57b40
+  data.tar.gz: 86b00458bc103bbd7c953bf4842ccedae8d4f9cd
+SHA512:
+  metadata.gz: 5c98fd40561face8eb970ce8ac4d7de721835999a137f3ca6f25fd2761ac96160833d2c996f9d497a41202e8d51ea4c2cc7f95b17a13469d53c4f152c4b5dc8b
+  data.tar.gz: d6519d1439e8e86d67469d3cbac343d7f033123dd673a488469e800f3fa2567a152f6225b993a28d719f6ee68ce278ddbd4085a8648c131193fae90a544f82c0

data/.gitignore

@@ -0,0 +1,2 @@
+*.swp
+*.gem

data/.rubocop.yml

@@ -0,0 +1,10 @@
+Metrics/ClassLength:
+  Max: 104
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 21
+  Enabled: false
+
+Style/FileName:
+ Enabled: false

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,102 @@
+PATH
+  remote: .
+  specs:
+    grape-route-helpers (1.0.0)
+      activesupport
+      grape
+      rake
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.3)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    ast (2.0.0)
+    astrolabe (1.3.0)
+      parser (>= 2.2.0.pre.3, < 3.0)
+    axiom-types (0.1.1)
+      descendants_tracker (~> 0.0.4)
+      ice_nine (~> 0.11.0)
+      thread_safe (~> 0.3, >= 0.3.1)
+    builder (3.2.2)
+    coderay (1.1.0)
+    coercible (1.0.0)
+      descendants_tracker (~> 0.0.1)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.2.5)
+    equalizer (0.0.11)
+    grape (0.12.0)
+      activesupport
+      builder
+      hashie (>= 2.1.0)
+      multi_json (>= 1.3.2)
+      multi_xml (>= 0.5.2)
+      rack (>= 1.3.0)
+      rack-accept
+      rack-mount
+      virtus (>= 1.0.0)
+    hashie (3.4.2)
+    i18n (0.7.0)
+    ice_nine (0.11.1)
+    json (1.8.3)
+    method_source (0.8.2)
+    minitest (5.7.0)
+    multi_json (1.11.1)
+    multi_xml (0.5.5)
+    parser (2.3.0.pre.2)
+      ast (>= 1.1, < 3.0)
+    powerpack (0.1.1)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rack (1.6.4)
+    rack-accept (0.4.5)
+      rack (>= 0.4)
+    rack-mount (0.8.3)
+      rack (>= 1.0.0)
+    rainbow (2.0.0)
+    rake (10.4.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.1)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    rubocop (0.32.1)
+      astrolabe (~> 1.3)
+      parser (>= 2.2.2.5, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.4)
+    ruby-progressbar (1.7.5)
+    slop (3.6.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    virtus (1.0.5)
+      axiom-types (~> 0.1)
+      coercible (~> 1.0)
+      descendants_tracker (~> 0.0, >= 0.0.3)
+      equalizer (~> 0.0, >= 0.0.9)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  grape-route-helpers!
+  pry
+  rspec
+  rubocop

data/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License (MIT)
+
+Copyright (c) 2015 Harper Henn
+
+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,118 @@
+# grape-route-helpers
+
+ Provides named route helpers for Grape APIs, similar to [Rails' route helpers](http://edgeguides.rubyonrails.org/routing.html#path-and-url-helpers).
+
+### Installation
+
+#### Rails
+
+ 1.) Add the gem to your Gemfile.
+
+```bash
+$ bundle install grape-route-helpers
+```
+
+#### Sinatra/Rack
+
+1.) Add the gem to your Gemfile if you're using Bundler.
+
+If you're not using Bundler to install/manage dependencies:
+
+```bash
+$ gem install grape-route-helpers
+```
+
+```ruby
+# environment setup file
+require 'grape'
+require 'grape/route_helpers'
+```
+
+2.) Write a rake task called `:environment` that loads the application's environment first. This gem's tasks are dependent on it. You could put this in the root of your project directory:
+
+```ruby
+# Rakefile
+
+require 'rake'
+require 'bundler'
+Bundler.setup
+require 'grape-route-helpers'
+require 'grape-route-helpers/tasks'
+
+desc 'load the Sinatra environment.'
+task :environment do
+  require File.expand_path('your_app_file', File.dirname(__FILE__))
+end
+```
+
+### Usage examples
+
+To see which methods correspond to which paths, and which options you can pass them:
+
+```bash
+$ rake grape:route_helpers
+```
+
+Use the methods inside your Grape API actions. Given this example API:
+
+```ruby
+class ExampleAPI < Grape::API
+  version 'v1'
+  prefix 'api'
+  format 'json'
+
+  get 'ping' do
+    'pong'
+  end
+
+  resource :cats do
+    get '/' do
+      %w(cats cats cats)
+    end
+
+    route_param :id do
+      get do
+        'cat'
+      end
+    end
+  end
+
+  route :any, '*anything' do
+    redirect api_v1_cats_path
+  end
+end
+```
+
+You'd have the following methods available inside your Grape API actions:
+
+```ruby
+# specifying the version when using Grape's "path" versioning strategy
+api_v1_ping_path # => '/api/v1/ping'
+
+# specifying the format
+api_v1_cats_path(format: 'xml') # => '/api/v1/cats.xml'
+
+# passing in values required to build a path
+api_v1_cats_path(id: 1) # => '/api/v1/cats/1'
+
+# catch-all paths have helpers
+api_v1_anything_path # => '/api/v1/*anything'
+```
+
+### Contributing
+
+1.) Fork it
+
+2.) Create your feature branch `(git checkout -b my-new-feature)`
+
+3.) Write specs for your feature
+
+4.) Commit your changes `(git commit -am 'Add some feature')`
+
+5.) Push to the branch `(git push origin my-new-feature)`
+
+6.) Create a new pull request
+
+### License
+
+See LICENSE

data/grape-route-helpers.gemspec

@@ -0,0 +1,21 @@
+require File.join(Dir.pwd, 'lib', 'grape-route-helpers', 'version')
+
+Gem::Specification.new do |gem|
+  gem.name        = 'grape-route-helpers'
+  gem.version     = GrapeRouteHelpers::VERSION
+  gem.licenses    = ['MIT']
+  gem.summary     = 'Route helpers for Grape'
+  gem.description = 'Route helpers for Grape'
+  gem.authors     = ['Harper Henn']
+  gem.email       = 'harper.henn@legitscript.com'
+  gem.files       = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.homepage    = 'https://github.com/reprah/grape-route-helpers'
+
+  gem.add_runtime_dependency 'grape'
+  gem.add_runtime_dependency 'activesupport'
+  gem.add_runtime_dependency 'rake'
+
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rubocop'
+end

data/lib/grape/route_helpers.rb

@@ -0,0 +1 @@
+require 'grape-route-helpers'

data/lib/grape-route-helpers/all_routes.rb

@@ -0,0 +1,15 @@
+module GrapeRouteHelpers
+  # methods to extend Grape::API's behavior so it can get a
+  # list of routes from all APIs and decorate them with
+  # the DecoratedRoute class
+  module AllRoutes
+    def decorated_routes
+      # memoize so that construction of decorated routes happens once
+      @decorated_routes ||= all_routes.map { |r| DecoratedRoute.new(r) }
+    end
+
+    def all_routes
+      subclasses.flat_map { |s| s.send(:prepare_routes) }
+    end
+  end
+end

data/lib/grape-route-helpers/decorated_route.rb

@@ -0,0 +1,134 @@
+module GrapeRouteHelpers
+  # wrapper around Grape::Route that adds a helper method
+  class DecoratedRoute
+    attr_reader :route, :helper_names, :helper_arguments
+
+    def initialize(route)
+      @route = route
+      @helper_names = []
+      @helper_arguments = required_helper_segments
+      define_path_helpers
+    end
+
+    def define_path_helpers
+      route_versions.each do |version|
+        route_attributes = { version: version }
+        method_name = path_helper_name(route_attributes)
+        @helper_names << method_name
+        define_path_helper(method_name, route_attributes)
+      end
+    end
+
+    def define_path_helper(method_name, route_attributes)
+      method_body = <<-RUBY
+        def #{method_name}(attributes = {})
+          attrs = HashWithIndifferentAccess.new(
+            #{route_attributes}.merge(attributes)
+          )
+
+          content_type = attrs.delete(:format)
+          path = '/' + path_segments_with_values(attrs).join('/')
+          extension = content_type ? '.' + content_type : ''
+
+          path + extension
+        end
+      RUBY
+      instance_eval method_body
+    end
+
+    def route_versions
+      if route_version
+        route_version.split('|')
+      else
+        [nil]
+      end
+    end
+
+    def path_helper_name(opts = {})
+      segments = path_segments_with_values(opts)
+
+      name = if segments.empty?
+               'root'
+             else
+               segments.join('_')
+             end
+      name + '_path'
+    end
+
+    def segment_to_value(segment, opts = {})
+      options = HashWithIndifferentAccess.new(
+        route_options.merge(opts)
+      )
+
+      if dynamic_segment?(segment)
+        key = segment.slice(1..-1)
+        options[key]
+      else
+        segment
+      end
+    end
+
+    def path_segments_with_values(opts)
+      segments = path_segments.map { |s| segment_to_value(s, opts) }
+      segments.reject(&:blank?)
+    end
+
+    def path_segments
+      pattern = %r{\(/?\.:?\w+\)|/|\*}
+      route_path.split(pattern).reject(&:blank?)
+    end
+
+    def dynamic_path_segments
+      segments = path_segments.select do |segment|
+        dynamic_segment?(segment)
+      end
+      segments.map { |s| s.slice(1..-1) }
+    end
+
+    def dynamic_segment?(segment)
+      segment.start_with?(':')
+    end
+
+    def required_helper_segments
+      segments_in_options = dynamic_path_segments.select do |segment|
+        route_options[segment.to_sym]
+      end
+      dynamic_path_segments - segments_in_options
+    end
+
+    def optional_segments
+      ['format']
+    end
+
+    def uses_segments_in_path_helper?(segments)
+      requested = segments - optional_segments
+      required = required_helper_segments
+
+      if requested.empty? && required.empty?
+        true
+      else
+        requested.all? do |segment|
+          required.include?(segment)
+        end
+      end
+    end
+
+    # accessing underlying Grape::Route
+
+    def route_path
+      route.route_path
+    end
+
+    def route_options
+      route.instance_variable_get(:@options)
+    end
+
+    def route_version
+      route.route_version
+    end
+
+    def route_namespace
+      route.route_namespace
+    end
+  end
+end

data/lib/grape-route-helpers/named_route_matcher.rb

@@ -0,0 +1,28 @@
+module GrapeRouteHelpers
+  # methods to extend Grape::Endpoint so that calls
+  # to unknown methods will look for a route with a matching
+  # helper function name
+  module NamedRouteMatcher
+    def method_missing(method_id, *arguments)
+      segments = arguments.first || {}
+
+      route = Grape::API.decorated_routes.detect do |r|
+        route_match?(r, method_id, segments)
+      end
+
+      if route
+        route.send(method_id, *arguments)
+      else
+        super
+      end
+    end
+
+    def route_match?(route, method_name, segments)
+      return false unless route.respond_to?(method_name)
+      fail ArgumentError,
+           'Helper options must be a hash' unless segments.is_a?(Hash)
+      requested_segments = segments.keys.map(&:to_s)
+      route.uses_segments_in_path_helper?(requested_segments)
+    end
+  end
+end

data/lib/grape-route-helpers/railtie.rb

@@ -0,0 +1,9 @@
+module GrapeRouteHelpers
+  #
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      files = File.join(File.dirname(__FILE__), '../tasks/*.rake')
+      Dir[files].each { |f| load f }
+    end
+  end
+end

data/lib/grape-route-helpers/route_displayer.rb

@@ -0,0 +1,29 @@
+module GrapeRouteHelpers
+  # class for displaying the path, helper method name,
+  # and required arguments for every Grape::Route.
+  class RouteDisplayer
+    def route_attributes
+      Grape::API.decorated_routes.map do |route|
+        {
+          route_path: route.route_path,
+          helper_names: route.helper_names,
+          helper_arguments: route.helper_arguments
+        }
+      end
+    end
+
+    def display
+      puts("== GRAPE ROUTE HELPERS ==\n\n")
+      route_attributes.each do |attributes|
+        printf("%s: %s\n", 'Path', attributes[:route_path])
+        printf("%s: %s\n",
+               'Helper Method',
+               attributes[:helper_names].join(', '))
+        printf("%s: %s\n",
+               'Arguments',
+               attributes[:helper_arguments].join(', '))
+        puts("\n")
+      end
+    end
+  end
+end

data/lib/grape-route-helpers/tasks.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../tasks/*.rake')].each { |f| load f }

data/lib/grape-route-helpers/version.rb

@@ -0,0 +1,4 @@
+# Gem version
+module GrapeRouteHelpers
+  VERSION = '1.0.0'
+end

data/lib/grape-route-helpers.rb

@@ -0,0 +1,16 @@
+require 'grape'
+require 'active_support'
+require 'active_support/core_ext/class'
+
+require 'grape-route-helpers/decorated_route'
+require 'grape-route-helpers/named_route_matcher'
+require 'grape-route-helpers/all_routes'
+require 'grape-route-helpers/route_displayer'
+
+#
+module GrapeRouteHelpers
+  require 'grape-route-helpers/railtie' if defined?(Rails)
+end
+
+Grape::API.extend GrapeRouteHelpers::AllRoutes
+Grape::Endpoint.send(:include, GrapeRouteHelpers::NamedRouteMatcher)

data/lib/tasks/grape_route_helpers.rake

@@ -0,0 +1,6 @@
+namespace :grape do
+  desc 'Print route helper methods.'
+  task routes: :environment do
+    GrapeRouteHelpers::RouteDisplayer.new.display
+  end
+end

data/spec/grape_route_helpers/decorated_route_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe GrapeRouteHelpers::DecoratedRoute do
+  let(:api) { Spec::Support::RouteMatcherHelpers.api }
+
+  let(:routes) do
+    api.routes.map do |route|
+      described_class.new(route)
+    end
+  end
+
+  let(:index_route) do
+    routes.detect { |route| route.route_namespace == '/cats' }
+  end
+
+  let(:show_route) do
+    routes.detect { |route| route.route_namespace == '/cats/:id' }
+  end
+
+  let(:catch_all_route) do
+    routes.detect { |route| route.route_path =~ /\*/ }
+  end
+
+  describe '#helper_names' do
+    context 'when an API has multiple versions' do
+      let(:api_versions) { %w(beta alpha v1) }
+
+      before do
+        api.version api_versions
+      end
+
+      it "returns the route's helper name for each version" do
+        helper_names = show_route.helper_names
+        expect(helper_names.size).to eq(api_versions.size)
+      end
+    end
+
+    context 'when an API has one version' do
+      it "returns the route's helper name for that version" do
+        helper_name = show_route.helper_names.first
+        expect(helper_name).to eq('api_v1_cats_path')
+      end
+    end
+  end
+
+  describe '#helper_arguments' do
+    context 'when no user input is needed to generate the correct path' do
+      it 'returns an empty array' do
+        expect(index_route.helper_arguments).to eq([])
+      end
+    end
+
+    context 'when user input is needed to generate the correct path' do
+      it 'returns an array of required segments' do
+        expect(show_route.helper_arguments).to eq(['id'])
+      end
+    end
+  end
+
+  describe '#path_segments_with_values' do
+    context 'when path has dynamic segments' do
+      it 'replaces segments with corresponding values found in @options' do
+        opts = { id: 1 }
+        result = show_route.path_segments_with_values(opts)
+        expect(result).to include(1)
+      end
+
+      context 'when options contains string keys' do
+        it 'replaces segments with corresponding values found in the options' do
+          opts = { 'id' => 1 }
+          result = show_route.path_segments_with_values(opts)
+          expect(result).to include(1)
+        end
+      end
+    end
+  end
+
+  describe '#path_helper_name' do
+    it "returns the name of a route's helper method" do
+      expect(index_route.path_helper_name).to eq('api_v1_cats_path')
+    end
+
+    context 'when the path is the root path' do
+      let(:api_with_root) do
+        Class.new(Grape::API) do
+          get '/' do
+          end
+        end
+      end
+
+      let(:root_route) do
+        grape_route = api_with_root.routes.first
+        described_class.new(grape_route)
+      end
+
+      it 'returns "root_path"' do
+        result = root_route.path_helper_name
+        expect(result).to eq('root_path')
+      end
+    end
+
+    context 'when the path is a catch-all path' do
+      it 'returns a name without the glob star' do
+        result = catch_all_route.path_helper_name
+        expect(result).to eq('api_v1_path_path')
+      end
+    end
+  end
+
+  describe '#segment_to_value' do
+    context 'when segment is dynamic' do
+      it 'returns the value the segment corresponds to' do
+        result = index_route.segment_to_value(':version')
+        expect(result).to eq('v1')
+      end
+
+      context 'when segment is found in options' do
+        it 'returns the value found in options' do
+          options = { id: 1 }
+          result = show_route.segment_to_value(':id', options)
+          expect(result).to eq(1)
+        end
+      end
+    end
+
+    context 'when segment is static' do
+      it 'returns the segment' do
+        result = index_route.segment_to_value('api')
+        expect(result).to eq('api')
+      end
+    end
+  end
+
+  describe 'path helper method' do
+    context 'when helper does not require arguments' do
+      it 'returns the correct path' do
+        path = index_route.api_v1_cats_path
+        expect(path).to eq('/api/v1/cats')
+      end
+    end
+
+    context 'when arguments are needed required to construct the right path' do
+      context 'when not missing arguments' do
+        it 'returns the correct path' do
+          path = show_route.api_v1_cats_path(id: 1)
+          expect(path).to eq('/api/v1/cats/1')
+        end
+      end
+    end
+
+    context "when a route's API has multiple versions" do
+      before(:each) do
+        api.version %w(v1 v2)
+      end
+
+      it 'returns a path for each version' do
+        expect(index_route.api_v1_cats_path).to eq('/api/v1/cats')
+        expect(index_route.api_v2_cats_path).to eq('/api/v2/cats')
+      end
+    end
+
+    context 'when a format is given' do
+      it 'returns the path with a correct extension' do
+        path = show_route.api_v1_cats_path(id: 1, format: 'xml')
+        expect(path).to eq('/api/v1/cats/1.xml')
+      end
+    end
+  end
+end

data/spec/grape_route_helpers/named_route_matcher_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe GrapeRouteHelpers::NamedRouteMatcher do
+  include described_class
+
+  let(:api) { Spec::Support::RouteMatcherHelpers.api }
+
+  let(:routes) do
+    api
+    Grape::API.decorated_routes
+  end
+
+  let(:ping_route) do
+    routes.detect do |route|
+      route.route_path =~ /ping/
+    end
+  end
+
+  let(:index_route) do
+    routes.detect do |route|
+      route.route_namespace =~ /cats$/
+    end
+  end
+
+  let(:show_route) do
+    routes.detect do |route|
+      route.route_namespace =~ %r{cats/:id}
+    end
+  end
+
+  describe '#route_match?' do
+    context 'when route responds to a method name' do
+      let(:route) { ping_route }
+      let(:method_name) { :api_v1_ping_path }
+      let(:segments) { {} }
+
+      context 'when segments is not a hash' do
+        it 'raises an ArgumentError' do
+          expect do
+            route_match?(route, method_name, 1234)
+          end.to raise_error(ArgumentError)
+        end
+      end
+
+      it 'returns true' do
+        is_match = route_match?(route, method_name, segments)
+        expect(is_match).to eq(true)
+      end
+
+      context 'when requested segments contains expected options' do
+        let(:segments) { { 'format' => 'xml' } }
+
+        it 'returns true' do
+          is_match = route_match?(route, method_name, segments)
+          expect(is_match).to eq(true)
+        end
+
+        context 'when no dynamic segments are requested' do
+          context 'when the route requires dynamic segments' do
+            let(:route) { show_route }
+            let(:method_name) { :ap1_v1_cats_path }
+
+            it 'returns false' do
+              is_match = route_match?(route, method_name, segments)
+              expect(is_match).to eq(false)
+            end
+          end
+
+          context 'when the route does not require dynamic segments' do
+            it 'returns true' do
+              is_match = route_match?(route, method_name, segments)
+              expect(is_match).to eq(true)
+            end
+          end
+        end
+
+        context 'when route requires the requested segments' do
+          let(:route) { show_route }
+          let(:method_name) { :api_v1_cats_path }
+          let(:segments) { { id: 1 } }
+
+          it 'returns true' do
+            is_match = route_match?(route, method_name, segments)
+            expect(is_match).to eq(true)
+          end
+        end
+
+        context 'when route does not require the requested segments' do
+          let(:segments) { { some_option: 'some value' } }
+
+          it 'returns false' do
+            is_match = route_match?(route, method_name, segments)
+            expect(is_match).to eq(false)
+          end
+        end
+      end
+
+      context 'when segments contains unexpected options' do
+        let(:segments) { { some_option: 'some value' } }
+
+        it 'returns false' do
+          is_match = route_match?(route, method_name, segments)
+          expect(is_match).to eq(false)
+        end
+      end
+    end
+
+    context 'when route does not respond to a method name' do
+      let(:method_name) { :some_other_path }
+      let(:route) { ping_route }
+      let(:segments) { {} }
+
+      it 'returns false' do
+        is_match = route_match?(route, method_name, segments)
+        expect(is_match).to eq(false)
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    context 'when method name matches a Grape::Route path helper name' do
+      it 'returns the path for that route object' do
+        api
+
+        path = api_v1_ping_path
+        expect(path).to eq('/api/v1/ping')
+      end
+
+      context 'when argument to the helper is not a hash' do
+        it 'raises an ArgumentError' do
+          api
+
+          expect do
+            api_v1_ping_path(1234)
+          end.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    context 'when method name does not match a Grape::Route path helper name' do
+      it 'raises a NameError' do
+        api
+
+        expect do
+          some_method_name
+        end.to raise_error(NameError)
+      end
+    end
+  end
+
+  context 'when Grape::Route objects share the same helper name' do
+    context 'when helpers require different segments to generate their path' do
+      it 'uses arguments to infer which route to use' do
+        api
+
+        show_path = api_v1_cats_path('id' => 1)
+        expect(show_path).to eq('/api/v1/cats/1')
+
+        index_path = api_v1_cats_path
+        expect(index_path).to eq('/api/v1/cats')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.expand_path('lib')
+
+require 'pry'
+require 'grape/route_helpers'
+
+support_files = Dir.glob('spec/support/*')
+support_files.each { |f| require File.expand_path(f) }
+
+include Spec::Support::RouteMatcherHelpers

data/spec/support/route_matcher_helpers.rb

@@ -0,0 +1,34 @@
+module Spec
+  module Support
+    # container for methods used in specs
+    module RouteMatcherHelpers
+      def self.api
+        Class.new(Grape::API) do
+          version 'v1'
+          prefix 'api'
+          format 'json'
+
+          get 'ping' do
+            'pong'
+          end
+
+          resource :cats do
+            get '/' do
+              %w(cats cats cats)
+            end
+
+            route_param :id do
+              get do
+                'cat'
+              end
+            end
+          end
+
+          route :any, '*path' do
+            'catch-all route'
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: grape-route-helpers
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Harper Henn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: grape
+  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: activesupport
+  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: rake
+  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: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Route helpers for Grape
+email: harper.henn@legitscript.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rubocop.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- grape-route-helpers.gemspec
+- lib/grape-route-helpers.rb
+- lib/grape-route-helpers/all_routes.rb
+- lib/grape-route-helpers/decorated_route.rb
+- lib/grape-route-helpers/named_route_matcher.rb
+- lib/grape-route-helpers/railtie.rb
+- lib/grape-route-helpers/route_displayer.rb
+- lib/grape-route-helpers/tasks.rb
+- lib/grape-route-helpers/version.rb
+- lib/grape/route_helpers.rb
+- lib/tasks/grape_route_helpers.rake
+- spec/grape_route_helpers/decorated_route_spec.rb
+- spec/grape_route_helpers/named_route_matcher_spec.rb
+- spec/spec_helper.rb
+- spec/support/route_matcher_helpers.rb
+homepage: https://github.com/reprah/grape-route-helpers
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Route helpers for Grape
+test_files: []
+has_rdoc: