modular_routes 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 954ed3363ece12cbe51eca5df6783f6066d49b3b5320dbcf7e9e10d0acf4bc05
-  data.tar.gz: 80fd6d08afa02b8502999c5ed5d37ca6104b64ef4714464f6adb0407d00fb364
+  metadata.gz: 5341830eca8ac468d9bf1843691214bf42e7806a9dedee7aa363227b39f2fb1a
+  data.tar.gz: d0ce8a5bd66d31555ab827efafaec86e512939ba8c21470e6738ede33da9a200
 SHA512:
-  metadata.gz: 8415af3f02b945890d14770c4e92d1bb2dfb3779773bdff86f6a87aa3e1417cb1c67fb6710c581b33031dc6bdf350fce97e15aa245c2fb7f07327e031c942397
-  data.tar.gz: 6aad4a4706157f87818541122dc520f83eb22eca43167d08162b40eb575546c82e674c90d83d0882be7aa1d98e82f09429e922aa1aaac4dfbc514710f878c73e
+  metadata.gz: f8ad0fa09d007407fb020109a93b33d7cf6c6b21a041759d5c556b76cb15cfd8c109ea10dac1b9d670d52cee9d1ff43dfe0c9357e88cdcffea3b92a46032d11a
+  data.tar.gz: c4581eede9b12a585ae8d409ad91a5405e4fbf4b040187aa1a41cd94f3599346c5ab0d5e53b709a4d2a37a11f6a93965e1c25da6c2098a1297295efdf7bcb3a2

data/CHANGELOG.md

@@ -1,5 +1,71 @@
-## [Unreleased]
+## [v0.2.0] - 2021-07-21
 
-## [0.1.0] - 2021-05-24
+**REMOVED**
+
+- `modular_route` helper was removed due to lack of syntax flexibility and a bit of inline verbosity.
+
+**NEW**
+
+- `modular_routes` helper was added to fix the problems encountered on the previous helper. Check the example below:
+
+  ```ruby
+    modular_routes do
+      resources :books
+
+      get :about, to: "about#index"
+    end
+  ```
+
+  The idea was to bring simplicity and proximity to what you already write in your routes file.
+
+- `namespace` support`
+
+  ```ruby
+    namespace :v1 do
+      resources :books
+    end
+  ```
+
+  It falls back to Rails default behavior.
+
+- `scope` support
+
+  ```ruby
+    scope :v1 do
+      resources :books
+    end
+
+    scope module: :v1 do
+      resources :books
+    end
+  ```
+
+  It falls back to Rails default behavior. In this example it recognizes `/v1/books` and `/books` expecting `BooksController` and `V1::BooksController` respectively.
+
+- Nested resources support
+
+  ```ruby
+    modular_routes do
+      resources :books do
+        resources :comments
+      end
+    end
+  ```
+
+  It recognizes paths like `/books/1/comments/2`.
+
+- Standalone (non-resourceful) routes
+
+  ```ruby
+    modular_routes do
+      get :about, to: "about#index"
+    end
+  ```
+
+  It expects `About::IndexController` to exist in `controllers/about/index_controller.rb`. They don't belong to a resourceful scope.
+
+  If `to` doesn't match `controller#action` pattern, it falls back to Rails default behavior.
+
+## [0.1.1] - 2021-07-15
 
 - Initial release

data/README.md

@@ -5,16 +5,18 @@
 
 # Modular Routes
 
-_A simple way of having dedicated controllers for each of your route actions in Rails._
+_Dedicated controllers for each of your Rails route actions._
 
-[![gem version](https://img.shields.io/gem/v/modular_routes)][gem]
+[![gem version](https://img.shields.io/gem/v/modular_routes?color=blue)][gem]
 [![CI](https://github.com/vitoravelino/modular_routes/actions/workflows/ci.yml/badge.svg)][ci]
 [![Coverage](https://github.com/vitoravelino/modular_routes/actions/workflows/coverage.yml/badge.svg)][coverage]
 [![Maintainability](https://img.shields.io/codeclimate/maintainability/vitoravelino/modular_routes)][codeclimate]
 
 If you've ever used [Hanami routes](https://guides.hanamirb.org/v1.3/routing/restful-resources/) or already use dedicated controllers for each route action, this gem might be useful.
 
-Disclaimer: There's no better/worse nor right/wrong approach, it's up to you to decide how you prefer to organize the controllers and routes of your application.
+**Disclaimer:** There's no better/worse nor right/wrong approach, it's up to you to decide how you prefer to organize the controllers and routes of your application.
+
+Docs: [Unreleased](https://github.com/vitoravelino/modular_routes/blob/main/README.md), [v0.2.0](https://github.com/vitoravelino/modular_routes/blob/v0.2.0/README.md), [v0.1.1](https://github.com/vitoravelino/modular_routes/blob/v0.1.1/README.md)
 
 ## Motivation
 
@@ -32,7 +34,7 @@ Let's imagine that you have to design a full RESTful resource named `articles` w
 | GET       | /articles/stats       |
 | POST      | /articles/:id/archive |
 
-How would you organize the controllers and routes of this application?
+**How would you organize the controllers and routes of this application?**
 
 The most common approach is to have all the actions (RESTful and customs) in the same controller.
 
@@ -195,7 +197,7 @@ end
 
 This is the best approach in my opinion because your controller will contain only code related to that specific route action. It will also be easier to test and maintain the code.
 
-If you've decided to go with the last approach, unless you organizes your routes in [separated files](https://guides.rubyonrails.org/routing.html#breaking-up-very-large-route-file-into-multiple-small-ones), your `config/routes.rb` might get really messy as your application grows due to verbosity.
+If you've decided to go with the last approach, unless you organize your routes in [separated files](https://guides.rubyonrails.org/routing.html#breaking-up-very-large-route-file-into-multiple-small-ones), your `config/routes.rb` might get really messy as your application grows due to verbosity.
 
 So, what if we had a simpler way of doing all of that? Let's take a look at how modular routes can help us.
 
@@ -217,20 +219,22 @@ Or install it yourself as:
 
 ## Usage
 
-`modular_route` uses `resource` and `resources` route helpers behind the scenes. So you can pretty much use almost everything you already use with them except for a few [limitations](#limitations) that will be explained later.
+`modular_routes` uses Rails route helpers behind the scenes. So you can pretty much use everything except for a few [limitations](#limitations) that will be detailed later.
 
-For the same example used in the [motivation](#motivation) section, using modular routes we now have
+For the same example used in the [motivation](#motivation), using modular routes we now have
 
 ```ruby
 # routes.rb
 
-modular_route resources: :articles, all: true do
-  collection do
-    post :stats
-  end
+modular_routes do
+  resources :articles do
+    collection do
+      post :stats
+    end
 
-  member do
-    post :archive
+    member do
+      post :archive
+    end
   end
 end
 ```
@@ -240,16 +244,14 @@ or to be shorter
 ```ruby
 # routes.rb
 
-modular_route resources: :articles, all: true do
-  post :stats,   on: :collection
-  post :archive, on: :member
+modular_routes do
+  resources :articles do
+    post :stats,   on: :collection
+    post :archive, on: :member
+  end
 end
 ```
 
-The only mandatory option to use `modular_route` helper is to pass `:resources` or `:resource` as key with the following resource name.
-
-To generate all RESTful routes, you must pass `all: true`. Otherwise nothing will happen unless you pass a block with additional routes.
-
 The output routes for the code above would be
 
 | HTTP Verb | Path                  | Controller#Action     | Named Route Helper        |
@@ -266,22 +268,24 @@ The output routes for the code above would be
 
 ### Restricting routes
 
-You can restrict the routes for the RESTful with `:only` and `:except` similar to what you can do in Rails by default.
+You can restrict resource RESTful routes with `:only` and `:except` similar to what you can do in Rails.
 
 ```ruby
-modular_route resources: :articles, only: [:index, :show]
-```
+modular_routes do
+  resources :articles, only: [:index, :show]
 
-```ruby
-modular_route resources: :articles, except: [:destroy]
+  resources :comments, except: [:destroy]
+end
 ```
 
 ### Renaming paths
 
-As in Rails you can simply use `:path` attribute.
+As in Rails you can use `:path` to rename route paths.
 
 ```ruby
-modular_route resources: :articles, all: true, path: 'posts'
+modular_routes do
+  resources :articles, path: 'posts'
+end
 ```
 
 is going to produce
@@ -296,25 +300,15 @@ is going to produce
 | PATCH/PUT | /posts/:id      | articles/update#call  | article_path(:id)      |
 | DELETE    | /posts/:id      | articles/destroy#call | article_path(:id)      |
 
-### API mode
-
-If your Rails app is with API only mode, then `:edit` and `:new` actions won't be applied.
+### Nesting
 
-### Limitations
-
-Some of the restrictions are:
-
-- `concerns` won't work
-- `constraints` only as option and not block
-- no support for nesting
-
-#### Nesting
-
-Even without nesting support you can emulate what the expected behaviour would be mixing `namespace` and `path` as detailed below
+As of version `0.2.0`, modular routes supports nesting just like Rails.
 
 ```ruby
-namespace :books, path: 'books/:book_id' do
-  modular_route resources: :reviews, all: true
+modular_routes do
+  resources :books, only: [] do
+    resources :reviews
+  end
 end
 ```
 
@@ -330,6 +324,77 @@ The output routes for that would be
 | PATCH/PUT | /books/:book_id/reviews/:id      | books/reviews/update#call  | books_reviews_path(:id)         |
 | DELETE    | /books/:book_id/reviews/:id      | books/reviews/destroy#call | books_reviews_path(:id)         |
 
+### Non-resourceful routes (standalone)
+
+Sometimes you want to declare a non-resourceful routes and its straightforward without modular routes:
+
+```ruby
+  get :about, to: "about/show#call"
+```
+
+Even being pretty simple, with modular routes you can omit the `#call` action like
+
+```ruby
+modular_routes do
+  get :about, to: "about#show"
+end
+```
+
+It expects `About::IndexController` to exist in `controllers/about/index_controller.rb`.
+
+If `to` doesn't match `controller#action` pattern, it falls back to Rails default behavior.
+
+### Scope
+
+`scope` falls back to Rails default behavior, so you can use it just like you would do it outside modular routes.
+
+```ruby
+modular_routes do
+  scope :v1 do
+    resources :books
+  end
+
+  scope module: :v1 do
+    resources :books
+  end
+end
+```
+
+In this example it recognizes `/v1/books` and `/books` expecting `BooksController` and `V1::BooksController` respectively.
+
+### Namespace
+
+As `scope`, `namespace` also falls back to Rails default behavior:
+
+```ruby
+modular_routes do
+  namespace :v1 do
+    resources :books
+  end
+end
+```
+
+| HTTP Verb | Path               | Controller#Action     | Named Route Helper  |
+| --------- | ------------------ | --------------------- | ------------------- |
+| GET       | /v1/books          | v1/books/index#call   | books_path          |
+| GET       | /v1/books/new      | v1/books/new#call     | new_book_path       |
+| POST      | /v1/books          | v1/books/create#call  | books_path          |
+| GET       | /v1/books/:id      | v1/books/show#call    | book_path(:id)      |
+| GET       | /v1/books/:id/edit | v1/books/edit#call    | edit_book_path(:id) |
+| PATCH/PUT | /v1/books/:id      | v1/books/update#call  | book_path(:id)      |
+| DELETE    | /v1/books/:id      | v1/books/destroy#call | book_path(:id)      |
+
+### API mode
+
+When `config.api_only` is set to `true`, `:edit` and `:new` routes won't be applied for resources.
+
+### Limitations
+
+- `constraints` are supported via `scope :constraints` and options
+- `concerns` are not supported inside `modular_routes` block but can be declared outside and used as options
+
+Let us know more limitations by creating a [new issue](https://github.com/vitoravelino/modular_routes/issues/new).
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/modular_routes.rb

@@ -4,9 +4,15 @@ require "action_dispatch"
 
 require_relative "modular_routes/builder"
 require_relative "modular_routes/extension"
-require_relative "modular_routes/options"
-require_relative "modular_routes/route/non_restful"
-require_relative "modular_routes/route/restful"
+require_relative "modular_routes/routable"
+require_relative "modular_routes/routable/non_restful"
+require_relative "modular_routes/routable/restful"
+require_relative "modular_routes/routable/standalone"
+require_relative "modular_routes/scopable"
+require_relative "modular_routes/scopable/namespace"
+require_relative "modular_routes/scopable/resource"
+require_relative "modular_routes/scopable/scope"
+require_relative "modular_routes/scopable/single_resource"
 require_relative "modular_routes/version"
 
 module ModularRoutes

data/lib/modular_routes/builder.rb

@@ -6,40 +6,93 @@ module ModularRoutes
 
     attr_reader :routes
 
-    def initialize(route_options)
-      @route_options = route_options
-      @routes = build_resource_routes
+    def initialize(api_only:)
+      @api_only = api_only
+      @scopes = []
+      @routes = []
     end
 
     HTTP_METHODS.each do |method|
-      define_method(method) do |action, options = {}|
-        mutable_options = { on: @on }
-        merged_options = mutable_options.merge(options)
+      define_method(method) do |action, action_options = {}|
+        options = { on: @on }.merge(action_options)
+        routable = build_routable(method, action, options)
 
-        @routes.unshift(Route::NonRestful.new(method, action, merged_options, @route_options))
+        if current_scope
+          current_scope.add(routable)
+        else
+          @routes.unshift(routable)
+        end
       end
     end
 
-    def collection
-      @on = :collection
-      yield
-    ensure
-      @on = nil
+    def collection(&block)
+      apply_inner_scope(:collection, &block)
     end
 
-    def member
-      @on = :member
-      yield
-    ensure
-      @on = nil
+    def member(&block)
+      apply_inner_scope(:member, &block)
+    end
+
+    def new(&block)
+      apply_inner_scope(:new, &block)
+    end
+
+    def namespace(namespace_name, **options, &block)
+      apply_scopable(:namespace, namespace_name, options, &block)
     end
 
-    private def build_resource_routes
-      @route_options.actions.map { |action| build_resource_route(action) }
+    def scope(*args, **options, &block)
+      apply_scopable(:scope, args, options, &block)
+    end
+
+    def resources(resources_name, **options, &block)
+      apply_scopable(:resources, resources_name, options, &block)
+    end
+
+    def resource(resource_name, **options, &block)
+      apply_scopable(:resource, resource_name, options, &block)
+    end
+
+    private def build_routable(method, action, options)
+      routable = if current_scope&.resource?
+        :non_restful
+      else
+        :standalone
+      end
+
+      Routable.for(routable, method, action, options)
+    end
+
+    private def build_scopable(type, name, options)
+      Scopable.for(type, name, options.merge(api_only: @api_only))
+    end
+
+    private def apply_scopable(type, name, options, &block)
+      scopable = build_scopable(type, name, options)
+      current_scope&.add(scopable)
+
+      apply_scope(scopable, &block)
+    end
+
+    private def apply_scope(scopable, &block)
+      @scopes << scopable
+
+      block&.call
+
+      @scopes.pop
+      @routes.unshift(scopable) unless current_scope
+    end
+
+    private def apply_inner_scope(type)
+      @on = type
+
+      yield
+
+      @on = nil
     end
 
-    private def build_resource_route(action)
-      Route::Restful.new(@route_options, action)
+    private def current_scope
+      @scopes.last
     end
   end
 end

data/lib/modular_routes/extension.rb

@@ -2,10 +2,11 @@
 
 module ModularRoutes
   module Extension
-    def modular_route(options, &block)
-      route_options = Options.new(options.merge(api_only: api_only?))
-      route_builder = Builder.new(route_options)
-      route_builder.instance_eval(&block) if block
+    def modular_routes(**options, &block)
+      api_only = options.fetch(:api_only, api_only?)
+
+      route_builder = Builder.new(api_only: api_only)
+      route_builder.instance_eval(&block)
       route_builder.routes.each { |route| route.apply(self) }
     end
   end

data/lib/modular_routes/routable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ModularRoutes
+  module Routable
+    def self.for(type, *args)
+      case type
+      when :standalone then Standalone.new(*args)
+      when :non_restful then NonRestful.new(*args)
+      when :restful then Restful.new(*args)
+      else raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/modular_routes/routable/non_restful.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ModularRoutes
+  module Routable
+    class NonRestful
+      def initialize(http_method, action, options)
+        @http_method = http_method
+        @action = action
+        @options = options
+      end
+
+      def apply(mapper)
+        mapper.public_send(@http_method, @action, options)
+      end
+
+      private def options
+        mutable_options = {
+          to: "#{@action}#call",
+        }
+
+        mutable_options.merge(@options)
+      end
+    end
+
+    private_constant :NonRestful
+  end
+end

data/lib/modular_routes/routable/restful.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ModularRoutes
+  module Routable
+    class Restful
+      def initialize(action, resource)
+        @action = action
+        @resource = resource
+      end
+
+      def apply(mapper)
+        mapper.public_send(resource_type, resource_name, options)
+      end
+
+      private def resource_type
+        @resource.resource_type
+      end
+
+      private def resource_name
+        @resource.name
+      end
+
+      private def resource_options
+        @resource.options
+      end
+
+      private def options
+        immutable = {
+          controller: @action,
+          only: @action,
+          action: :call,
+        }
+
+        resource_options.merge(immutable)
+      end
+    end
+
+    private_constant :Restful
+  end
+end

data/lib/modular_routes/routable/standalone.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ModularRoutes
+  module Routable
+    class Standalone
+      def initialize(http_method, action, options)
+        @http_method = http_method
+        @action = action
+        @options = options
+      end
+
+      def apply(mapper)
+        mapper.public_send(@http_method, @action, options)
+      end
+
+      private def options
+        to = @options.fetch(:to, nil)
+
+        if namespace_controller_pattern?(to)
+          namespace, controller = to.split("#")
+          @options[:to] = "#{namespace}/#{controller}#call"
+        end
+
+        @options
+      end
+
+      private def namespace_controller_pattern?(obj)
+        obj.is_a?(String) && obj.include?("#")
+      end
+    end
+
+    private_constant :Standalone
+  end
+end

data/lib/modular_routes/scopable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ModularRoutes
+  module Scopable
+    def self.for(type, *args)
+      case type
+      when :namespace then Namespace.new(*args)
+      when :resources then Resource.new(*args)
+      when :resource then SingleResource.new(*args)
+      when :scope then Scope.new(*args)
+      else raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/modular_routes/scopable/namespace.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ModularRoutes
+  module Scopable
+    class Namespace
+      def initialize(name, options)
+        @name = name
+        @options = options.except(:api_only)
+
+        @children = []
+      end
+
+      def add(route_or_scope)
+        @children << route_or_scope
+      end
+
+      def resource?
+        false
+      end
+
+      def apply(mapper)
+        mapper.namespace(@name, @options) do
+          @children.each { |route_or_scope| route_or_scope.apply(mapper) }
+        end
+      end
+    end
+
+    private_constant :Namespace
+  end
+end

data/lib/modular_routes/scopable/resource.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ModularRoutes
+  module Scopable
+    class Resource
+      attr_reader :name
+      attr_reader :options
+
+      def initialize(name, options)
+        @name = name
+        @children = []
+
+        @api_only = options.delete(:api_only)
+        @only = options.delete(:only) { default_actions }
+        @except = options.delete(:except)
+        @options = { module: name, only: [] }.merge(options)
+      end
+
+      def resource?
+        true
+      end
+
+      def resource_type
+        :resources
+      end
+
+      def add(route_or_scope)
+        @children << route_or_scope
+      end
+
+      def apply(mapper)
+        mapper.public_send(resource_type, @name, @options) do
+          @children.each { |route_or_scope| route_or_scope.apply(mapper) }
+        end
+
+        apply_restful_actions(mapper)
+      end
+
+      private def actions
+        return default_actions - Array(@except) if @except
+
+        Array(@only)
+      end
+
+      private def default_actions
+        if @api_only
+          [:index, :create, :show, :update, :destroy]
+        else
+          [:index, :create, :new, :edit, :show, :update, :destroy]
+        end
+      end
+
+      private def apply_restful_actions(mapper)
+        actions.each do |action|
+          Routable.for(:restful, action, self).apply(mapper)
+        end
+      end
+    end
+
+    private_constant :Resource
+  end
+end

data/lib/modular_routes/scopable/scope.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ModularRoutes
+  module Scopable
+    class Scope
+      def initialize(args, options)
+        @args = args
+        @options = options.except(:api_only)
+
+        @children = []
+      end
+
+      def add(route_or_scope)
+        @children << route_or_scope
+      end
+
+      def resource?
+        false
+      end
+
+      def apply(mapper)
+        mapper.scope(*@args, @options) do
+          @children.each { |route_or_scope| route_or_scope.apply(mapper) }
+        end
+      end
+    end
+
+    private_constant :Scope
+  end
+end

data/lib/modular_routes/scopable/single_resource.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ModularRoutes
+  module Scopable
+    class SingleResource < Resource
+      def resource_type
+        :resource
+      end
+
+      private def default_actions
+        if @api_only
+          [:create, :show, :update, :destroy]
+        else
+          [:create, :new, :edit, :show, :update, :destroy]
+        end
+      end
+    end
+
+    private_constant :SingleResource
+  end
+end

data/lib/modular_routes/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ModularRoutes
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/modular_routes.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Vítor Avelino"]
   spec.email         = ["contact@vitoravelino.me"]
 
-  spec.summary       = "A simple way of having dedicated controllers for each of your route actions in Rails"
+  spec.summary       = "Dedicated controllers for each of your Rails route actions"
   spec.description   = spec.summary
   spec.homepage      = "https://github.com/vitoravelino/modular_routes"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modular_routes
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Vítor Avelino
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-15 00:00:00.000000000 Z
+date: 2021-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -122,8 +122,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A simple way of having dedicated controllers for each of your route actions
-  in Rails
+description: Dedicated controllers for each of your Rails route actions
 email:
 - contact@vitoravelino.me
 executables: []
@@ -148,9 +147,15 @@ files:
 - lib/modular_routes.rb
 - lib/modular_routes/builder.rb
 - lib/modular_routes/extension.rb
-- lib/modular_routes/options.rb
-- lib/modular_routes/route/non_restful.rb
-- lib/modular_routes/route/restful.rb
+- lib/modular_routes/routable.rb
+- lib/modular_routes/routable/non_restful.rb
+- lib/modular_routes/routable/restful.rb
+- lib/modular_routes/routable/standalone.rb
+- lib/modular_routes/scopable.rb
+- lib/modular_routes/scopable/namespace.rb
+- lib/modular_routes/scopable/resource.rb
+- lib/modular_routes/scopable/scope.rb
+- lib/modular_routes/scopable/single_resource.rb
 - lib/modular_routes/version.rb
 - modular_routes.gemspec
 homepage: https://github.com/vitoravelino/modular_routes
@@ -177,6 +182,5 @@ requirements: []
 rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
-summary: A simple way of having dedicated controllers for each of your route actions
-  in Rails
+summary: Dedicated controllers for each of your Rails route actions
 test_files: []

data/lib/modular_routes/options.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module ModularRoutes
-  class Options
-    attr_reader :method
-    attr_reader :module
-    attr_reader :resource
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
-      @method = extract_resource_method
-      @resource = @options.delete(@method)
-      @module = @options.fetch(:module, @resource)
-      @api = @options.delete(:api_only) { false }
-
-      @only = @options.delete(:only)
-      @except = @options.delete(:except)
-      @all = @options.delete(:all)
-    end
-
-    def singular?
-      method == :resource
-    end
-
-    def actions
-      return default_actions if @all
-
-      return default_actions - Array(@except) if @except
-
-      Array(@only)
-    end
-
-    private def default_actions
-      actions = [:index, :create, :new, :edit, :show, :update, :destroy]
-
-      actions -= [:index] if singular?
-      actions -= [:edit, :new] if @api
-
-      actions
-    end
-
-    private def extract_resource_method
-      return :resource if options.include?(:resource)
-      return :resources if options.include?(:resources)
-
-      raise ArgumentError, "you must specify :resource or :resources for `modular_route`"
-    end
-  end
-end

data/lib/modular_routes/route/non_restful.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module ModularRoutes
-  module Route
-    class NonRestful
-      attr_reader :http_method
-      attr_reader :action
-
-      def initialize(http_method, action, options, scope_options)
-        @http_method = http_method
-        @action = action
-        @options = options
-        @scope_options = scope_options
-
-        unless @options.fetch(:on, nil)
-          raise ArgumentError,
-            "Non-RESTful route should be declared inside `member`/`collection` block or using `:on` key"
-        end
-      end
-
-      def apply(mapper)
-        method = @scope_options.method
-        resource = @scope_options.resource
-
-        mapper.public_send(method, resource, resource_options) do
-          mapper.public_send(http_method, action, options)
-        end
-      end
-
-      private def resource_options
-        immutable_options = {
-          only: [],
-          module: @scope_options.module,
-        }
-
-        @scope_options.options.merge(immutable_options)
-      end
-
-      private def options
-        mutable_options = {
-          to: "#{action}#call",
-        }
-
-        mutable_options.merge(@options)
-      end
-    end
-  end
-end

data/lib/modular_routes/route/restful.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module ModularRoutes
-  module Route
-    class Restful
-      def initialize(route_options, action)
-        @module = route_options.module
-        @resource = route_options.resource
-        @options = route_options.options
-        @method = route_options.method
-        @action = action
-      end
-
-      def apply(mapper)
-        mapper.public_send(@method, @resource, resource_options)
-      end
-
-      private def resource_options
-        immutable_options = {
-          controller: @action,
-          only: @action,
-          action: :call,
-        }
-
-        mutable_options = { module: @module }
-
-        mutable_options.merge(@options).merge(immutable_options)
-      end
-    end
-  end
-end