web_pipe 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc647eb09c8b7eb1d3bcfb910cc55e840285c6b1ab9bd9c69ea9b630f7a116fd
-  data.tar.gz: 6b667b8e71f1fac8d7c46a8160cbff273c70042bf1cc9b06da60c82a83fea5b2
+  metadata.gz: eb774cbbdd90831e9ffcd5dba76265c37585b65f56618aff8cfa311b78d2bea8
+  data.tar.gz: c456b68f6995308a740dacf97bb7177f140c51757fa6f680ecc7e515036d37a0
 SHA512:
-  metadata.gz: f52d9d4c5b381d13de8f27ae03e8fc8bfb2cfe7e020d507f934341c9823f7c2cb2d94ebddc500d9337a59c2437c8ae3899e1b7ef942ed5e1cfc073591f8ac56f
-  data.tar.gz: 0be15319332d738f2b8ff07d7cb9d73583d00bf907e8787a2b8ab0fadc88d235f441b08e546bf162a6fb6fca8953ab68c34077cf300c0d6c1bb26aa37fe8f964
+  metadata.gz: 118d6af2b98c082fa174b33e092744d82a5e2667e20bc717ef996fa9da1b934d44a618331527d2c328d02ce2ea0dc62b3649800f326cfc7516f9ba3ba23c8797
+  data.tar.gz: 32cb91bec0de9aaab6f48d48f4c68334a64fc3c5e944be4f6c20fccaacf1dab928b59809b0e50c129306d43951f0ef028812ab6196503cfff1d830cf8b5e658a

data/CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.10.0] - 2019-11-15
+### Added
+- `:rails` extension integrating with Ruby On Rails.
+  [[#36]](https://github.com/waiting-for-dev/web_pipe/pull/36)
+
 ## [0.9.0] - 2019-08-31
 ### Added
 - Comprehensive documentation.

data/README.md

@@ -10,40 +10,44 @@ In order to use in conjunction with [dry-rb](https://dry-rb.org/)
 ecosystem, see also
 [`dry-web-web_pipe`](https://github.com/waiting-for-dev/dry-web-web_pipe).
 
-1. [Introduction](/docs/introduction.md)
-1. [Design model](/docs/design_model.md)
-1. [Building a rack application](/docs/building_a_rack_application.md)
-1. [Plugging operations](/docs/plugging_operations.md)
-   1. [Resolving operations](/docs/plugging_operations/resolving_operations.md)
-   1. [Injecting operations](/docs/plugging_operations/injecting_operations.md)
-   1. [Composing operations](/docs/plugging_operations/composing_operations.md)
-1. [Using rack middlewares](/docs/using_rack_middlewares.md)
-   1. [Injecting middlewares](/docs/using_rack_middlewares/injecting_middlewares.md)
-   1. [Composing middlewares](/docs/using_rack_middlewares/composing_middlewares.md)
-1. [Composing applications](/docs/composing_applications.md)
-1. [Connection struct](/docs/connection_struct.md)
-   1. [Sharing data downstream](/docs/connection_struct/sharing_data_downstream.md)
-   1. [Halting the pipe](/docs/connection_struct/halting_the_pipe.md)
-   1. [Configuring the connection struct](/docs/connection_struct/configuring_the_connection_struct.md)
-1. [DSL free usage](/docs/dsl_free_usage.md)
-1. [Plugs](/docs/plugs.md)
-   1. [Config](/docs/plugs/config.md)
-   1. [ContentType](/docs/plugs/content_type.md)
-1. [Extensions](/docs/extensions.md)
-   1. [Container](/docs/extensions/container.md)
-   1. [Cookies](/docs/extensions/cookies.md)
-   1. [Flash](/docs/extensions/flash.md)
-   1. [Dry Schema](/docs/extensions/dry_schema.md)
-   1. [Dry View](/docs/extensions/dry_view.md)
-   1. [Params](/docs/extensions/params.md)
-   1. [Redirect](/docs/extensions/redirect.md)
-   1. [Router params](/docs/extensions/router_params.md)
-   1. [Session](/docs/extensions/session.md)
-   1. [URL](/docs/extensions/url.md)
+If you want to use it with a Rails project, don't miss docs for the [rails
+extension](docs/extensions/rails.md).
+
+1. [Introduction](docs/introduction.md)
+1. [Design model](docs/design_model.md)
+1. [Building a rack application](docs/building_a_rack_application.md)
+1. [Plugging operations](docs/plugging_operations.md)
+   1. [Resolving operations](docs/plugging_operations/resolving_operations.md)
+   1. [Injecting operations](docs/plugging_operations/injecting_operations.md)
+   1. [Composing operations](docs/plugging_operations/composing_operations.md)
+1. [Using rack middlewares](docs/using_rack_middlewares.md)
+   1. [Injecting middlewares](docs/using_rack_middlewares/injecting_middlewares.md)
+   1. [Composing middlewares](docs/using_rack_middlewares/composing_middlewares.md)
+1. [Composing applications](docs/composing_applications.md)
+1. [Connection struct](docs/connection_struct.md)
+   1. [Sharing data downstream](docs/connection_struct/sharing_data_downstream.md)
+   1. [Halting the pipe](docs/connection_struct/halting_the_pipe.md)
+   1. [Configuring the connection struct](docs/connection_struct/configuring_the_connection_struct.md)
+1. [DSL free usage](docs/dsl_free_usage.md)
+1. [Plugs](docs/plugs.md)
+   1. [Config](docs/plugs/config.md)
+   1. [ContentType](docs/plugs/content_type.md)
+1. [Extensions](docs/extensions.md)
+   1. [Container](docs/extensions/container.md)
+   1. [Cookies](docs/extensions/cookies.md)
+   1. [Flash](docs/extensions/flash.md)
+   1. [Dry Schema](docs/extensions/dry_schema.md)
+   1. [Dry View](docs/extensions/dry_view.md)
+   1. [Params](docs/extensions/params.md)
+   1. [Rails](docs/extensions/rails.md)
+   1. [Redirect](docs/extensions/redirect.md)
+   1. [Router params](docs/extensions/router_params.md)
+   1. [Session](docs/extensions/session.md)
+   1. [URL](docs/extensions/url.md)
 1. Recipes
-   1. [dry-rb integration](/docs/recipes/dry_rb_integration.md)
-   1. [hanami-router integration](/docs/recipes/hanami_router_integration.md)
-   1. [Using all RESTful methods](/docs/recipes/using_all_restful_methods.mb)
+   1. [dry-rb integration](docs/recipes/dry_rb_integration.md)
+   1. [hanami-router integration](docs/recipes/hanami_router_integration.md)
+   1. [Using all RESTful methods](docs/recipes/using_all_restful_methods.md)
 
 ```ruby
 # config.ru

data/docs/composing_applications.md

@@ -1,8 +1,8 @@
 # Composing applications
 
 Previously, we have seen how to [compose plugged
-operations](/docs/plugging_operations/composing_operations.md) and how to [compose
-rack middlewares](/docs/using_rack_middlewares/composing_middlewares.md). The logical
+operations](plugging_operations/composing_operations.md) and how to [compose
+rack middlewares](using_rack_middlewares/composing_middlewares.md). The logical
 next step is thinking about composing `web_pipe` applications, which is exactly
 the same as composing both operations and middlewares at the same time.
 

data/docs/connection_struct.md

@@ -69,7 +69,7 @@ run DummyApp.new
 
 As you can see, default available features are the very minimal to read from a
 request and to write a response. However, you can pick from several
-(extensions)[/docs/extensions.md] which will make your life much easier.
+(extensions)[extensions.md] which will make your life much easier.
 
 Immutability is a core design principle in `web_pipe`. All methods in
 `WebPipe::Conn` which are used to add data to it (both in core behaviour and

data/docs/connection_struct/configuring_the_connection_struct.md

@@ -1,6 +1,6 @@
 # Configuring the connection struct
 
-[Extensions](/docs/extensions.md) add extra behaviour to the connection struct.
+[Extensions](../extensions.md) add extra behaviour to the connection struct.
 Sometimes they need some user provided value to work properly or they may allow
 some tweak depending on user needs.
 
@@ -10,7 +10,7 @@ what they need is `#config` attribute, which is very similar to `#bag` except
 for its more private intention.
 
 In order to interact with `#config`, you can use the method `#add_config(key,
-value)` or [`Config` plug](/docs/plugs/config.md).
+value)` or [`Config` plug](../plugs/config.md).
 
 ```ruby
 class MyApp

data/docs/extensions/dry_schema.md

@@ -9,7 +9,7 @@ pipe of operations. It takes as arguments a `dry-schema` schema and a handler.
 On success, it makes output available at `WebPipe::Conn#sanitized_params`. On
 error, it calls given handler with the connection struct and validation result.
 
-This extension automatically loads [`:params` extension](/docs/extensions/params.md),
+This extension automatically loads [`:params` extension](params.md),
 as it takes `WebPipe::Conn#params` as input for the validation schema.
 
 Instead of providing an error handler as the second argument for the plug, you

data/docs/extensions/dry_view.md

@@ -37,7 +37,7 @@ end
 ```
 
 However, you can resolve a view from a container if you also use (`:container`
-extension)[/docs/extensions/container.md]:
+extension)[container.md]:
 
 ```ruby
 require 'dry_view'

data/docs/extensions/rails.md

@@ -0,0 +1,115 @@
+# Rails
+
+The first two things to keep in mind in order to integrate with Rails is
+that `WebPipe` instances are Rack applications and that rails router can
+perfectly [dispatch to a rack application](https://guides.rubyonrails.org/routing.html#routing-to-rack-applications). For example:
+
+```ruby
+# config/routes.rb
+get '/my_route', to: MyRoute.new
+
+# app/controllers/my_route.rb
+class MyRoute
+  include WebPipe
+
+  plug :set_response_body
+
+  private
+
+  def set_response_body(conn)
+    conn.set_response_body('Hello, World!')
+  end
+end
+```
+
+In order to do something like the previous example you don't need to enable
+this extension. Notice that rails took care of dispatching the request to our
+`WebPipe` rack application, which was then responsible for generating the
+response. In this case, it used a simple call to `#set_response_body`.
+
+It's quite possible that you don't need more than that in terms of rails
+integration. Of course, surely you want something more elaborate to generate
+responses. For that, you can use the view or template system you like. One
+option that will play specially well here is
+[`dry-view`](https://dry-rb.org/gems/dry-view/), which
+[integrates](https://github.com/dry-rb/dry-view/tree/master/examples/rails)
+itself easily with Rails. Furthermore, we have a tailored `dry_view`
+[extension](https://waiting-for-dev.github.io/web_pipe/docs/extensions/dry_view.html).
+
+You need to use this extension if:
+
+- You want to use `action_view` as rendering system.
+- You want to use rails url helpers from your `WebPipe` application.
+- You want to use controller helpers from your `WebPipe` application.
+
+Rails responsibilities for controlling the request/response cycle and the
+rendering process are a little bit tangled. For this reason, even if you
+want to use `WebPipe` applications instead of Rails controller actions you
+still have to use the typical top `ApplicationController` in order to define
+some behaviour for the view layer:
+
+- Which layout is applied to the template.
+- Which helpers will become available to the templates.
+- Where within `app/views/` templates are looked up.
+
+By default, the controller in use is `ActionController::Base`, which means that
+no layout is applied and only built-in helpers (for example,
+`number_as_currency`) are available. You can change it via the
+`:rails_controller` configuration option.
+
+The main method that this extension adds to `WebPipe::Conn` is `#render`,
+which just delegates to the [Rails
+implementation](https://api.rubyonrails.org/v6.0.1/classes/ActionController/Renderer.html)
+as you'd do in a typical rails controller. Remember that you can provide
+template instance variables through the keyword `:assigns`.
+
+```ruby
+# config/routes.rb
+get '/articles', to: ArticlesIndex.new
+
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base
+  # By default uses the layout in `layouts/application`
+end
+
+# app/controllers/articles_index.rb
+require 'web_pipe/plugs/config'
+
+WebPipe.load_extensions(:rails) # You can put it in an initializer
+
+class ArticlesIndex
+  include WebPipe
+
+  plug :config, WebPipe::Plugs::Config.(
+    rails_controller: ApplicationController
+  )
+
+  def render(conn)
+    conn.render(
+      template: 'articles/index',
+      assigns: { articles: Article.all }
+    )
+  end
+end
+```
+
+Notice that we used the keyword `template:` instead of taking advantage of
+automatic template lookup. We did that way so that we don't have to create also
+an `ArticlesController`, but it's up to you.
+
+Besides, this extension provides with two other methods:
+
+- `url_helpers` returns Rails router [url
+  helpers](https://api.rubyonrails.org/v6.0.1/classes/ActionView/Helpers/UrlHelper.html).
+- `helpers` returns the associated [controller
+  helpers](https://api.rubyonrails.org/classes/ActionController/Helpers.html).
+
+In all the examples we have supposed that we are putting `WebPipe` applications
+within `app/controllers/` directory. However, remember you can put them
+wherever you like as long as you respect rails [`autoload_paths`](https://guides.rubyonrails.org/autoloading_and_reloading_constants.html#autoload-paths).
+
+Here you have a link to a very simple and contrived example of a rails
+application integrating `web_pipe`:
+
+https://github.com/waiting-for-dev/rails-web_pipe
+

data/docs/extensions/router_params.md

@@ -2,7 +2,7 @@
 
 This extension can be used in order to merge placeholder parameters
 that usually routers support (like `get /users/:id`) to the parameters hash
-added through [`:params` extension](/docs/extensions/params.md) (which is
+added through [`:params` extension](params.md) (which is
 automatically loaded).
 
 What this extension does is adding a transformation function to the registry

data/docs/introduction.md

@@ -12,17 +12,17 @@ with [dry-rb](https://dry-rb.org/) ecosystem. If it helps, you can think of it
 as a decoupled web controller (as the C in MVC).
 
 `web_pipe` applications are built as a [pipe of
-operations](/docs/design_model.md) on an [immutable
-struct](/docs/connection_struct.md). The struct is automatically created
+operations](design_model.md) on an [immutable
+struct](connection_struct.md). The struct is automatically created
 with data from an HTTP request, and it contains methods to
 incrementally add data to generate an HTTP response. The pipe can
-be [halted](/docs/connection_struct/halting_the_pipe.md) at any moment,
+be [halted](connection_struct/halting_the_pipe.md) at any moment,
 taking away from all operations downstream any chance to modify the
 response.
 
 `web_pipe` has a modular design, with only the minimal functionalities needed
 to build a web application enabled by default. However, it ships with several
-[extensions](/docs/extensions.md) to make your life easier.
+[extensions](extensions.md) to make your life easier.
 
 Following there is a simple example. It is a web application that will check
 the value of a `user` parameter. When it is `Alice` or `Joe`, it will kindly
@@ -70,4 +70,4 @@ class HelloApp
 end
 
 run HelloApp.new
-``
+```

data/docs/plugging_operations.md

@@ -3,7 +3,7 @@
 You can plug operations to your application with the DSL method `plug`. The
 first argument it always takes is a symbol with the name you want
 to give to the operation (which is needed to allow
-[injection](/docs/plugging_operations/injecting_operations.md) on
+[injection](plugging_operations/injecting_operations.md) on
 initialization).
 
 ```ruby

data/docs/recipes/dry_rb_integration.md

@@ -4,8 +4,8 @@
 [dry-rb](https://dry-rb.org/) ecosystem. It shares same design
 principles and it ships with some extensions which even make this
 integration tighter (like
-[`:dry-view`](/docs/extensions/dry_view.md) or
-[`:dry-schema`](/docs/extensions/dry_schema.md) extensions).
+[`:dry-view`](../extensions/dry_view.md) or
+[`:dry-schema`](../extensions/dry_schema.md) extensions).
 
 If you want to use `web_pipe` with the rest of dry-rb libraries,
 your best bet is to use

data/docs/recipes/hanami_router_integration.md

@@ -22,4 +22,4 @@ end
 run router
 ```
 
-In order to perform [string matching with variables](https://github.com/hanami/router#string-matching-with-variables) you just need to load [`:router_params` extension](/docs/extensions/router_params.md).
+In order to perform [string matching with variables](https://github.com/hanami/router#string-matching-with-variables) you just need to load [`:router_params` extension](../extensions/router_params.md).

data/docs/recipes/using_all_restful_methods.md

@@ -9,7 +9,7 @@ request method in rack's env if a magical `_method` parameter or
 
 You have to be aware that if you use this middleware within a
 `web_pipe` application (through [`use` DSL
-method](docs/using_rack_middlewares.md)) it will have no effect.
+method](../using_rack_middlewares.md)) it will have no effect.
 When your `web_pipe` application takes control of the request it
 has already gone through the router, which is the one who should
 read the request method set by rack.

data/docs/using_rack_middlewares.md

@@ -9,7 +9,7 @@ encapsulate them in your application definition.
 In order to add rack middlewares to the stack, you have to use the DSL method
 `use`. The first argument it takes is a `Symbol` with the name you want to
 assign to it (which is needed to allow
-[injection](/docs/using_rack_middlewares/injecting_middlewares.md) on
+[injection](using_rack_middlewares/injecting_middlewares.md) on
 initialization). Then, it must follow the middleware class and any option it
 may need:
 

data/lib/web_pipe.rb

@@ -51,6 +51,10 @@ module WebPipe
     require 'web_pipe/extensions/params/params'
   end
 
+  register_extension :rails do
+    require 'web_pipe/extensions/rails/rails'
+  end
+
   register_extension :session do
     require 'web_pipe/extensions/session/session'
   end

data/lib/web_pipe/extensions/rails/rails.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'web_pipe/conn'
+
+module WebPipe
+  # Integrates with Rails framework.
+  #
+  # The first two things to keep in mind in order to integrate with Rails is
+  # that {WebPipe} instances are Rack applications and that rails router can
+  # perfectly dispatch to a rack application. For example:
+  #
+  # ```ruby
+  # # config/routes.rb
+  # get '/my_route', to: MyRoute.new
+  #
+  # # app/controllers/my_route.rb
+  # class MyRoute
+  #   include WebPipe
+  #
+  #   plug :set_response_body
+  #
+  #   private
+  #
+  #   def set_response_body(conn)
+  #     conn.set_response_body('Hello, World!')
+  #   end
+  # end
+  # ```
+  #
+  # In order to do something like the previous example you don't need to enable
+  # this extension. Notice that rails took care of dispatching the request to
+  # our {WebPipe} rack application, which was then responsible for generating the
+  # response. In this case, it used a simple call to
+  # {WebPipe::Conn#set_response_body}.
+  #
+  # It's quite possible that you don't need more than that in terms of rails
+  # integration. Of course, surely you want something more elaborate to generate
+  # responses. For that, you can use the view or template system you like. One
+  # option that will play specially well here is `dry-view`, which integrates
+  # itself easily with Rails. Furthermore, we have a tailored `dry_view`
+  # extension.
+  #
+  # You need to use this extension if:
+  #
+  # - You want to use `action_view` as rendering system.
+  # - You want to use rails url helpers from your {WebPipe} application.
+  # - You want to use controller helpers from your {WebPipe} application.
+  #
+  # Rails responsibilities for controlling the request/response cycle and the
+  # rendering process are a little bit tangled. For this reason, even if you
+  # want to use {WebPipe} applications instead of Rails controller actions you
+  # still have to use the typical top `ApplicationController` in order to define
+  # some behaviour for the view layer:
+  #
+  # - Which layout is applied to the template.
+  # - Which helpers will become available to the templates.
+  # - Where within `app/views/` templates are looked up.
+  #
+  # By default, the controller in use is `ActionController::Base`, which means
+  # that no layout is applied and only built-in helpers (for example,
+  # `number_as_currency`) are available. You can change it via the
+  # `:rails_controller` configuration option.
+  #
+  # The main method that this extension adds to {WebPipe::Conn} is `#render`,
+  # which just delegates to the Rails implementation as you'd do in a typical
+  # rails controller. Remember that you can provide template instance variables
+  # through the keyword `:assigns`.
+  #
+  # ```ruby
+  # # config/routes.rb
+  # get '/articles', to: ArticlesIndex.new
+  #
+  # # app/controllers/application_controller.rb
+  # class ApplicationController < ActionController::Base
+  #   # By default uses the layout in `layouts/application`
+  # end
+  # 
+  # # app/controllers/articles_index.rb
+  # require 'web_pipe/plugs/config'
+  #
+  #
+  # WebPipe.load_extensions(:rails) # You can put it in an initializer
+  #
+  # class ArticlesIndex
+  #   include WebPipe
+  #
+  #   plug :config, WebPipe::Plugs::Config.(
+  #     rails_controller: ApplicationController
+  #   )
+  #
+  #   def render(conn)
+  #     conn.render(
+  #       template: 'articles/index',
+  #       assigns: { articles: Article.all }
+  #     )
+  #   end
+  # end
+  # ```
+  #
+  # Notice that we used the keyword `template:` instead of taking advantage of
+  # automatic template lookup. We did that way so that we don't have to create
+  # also an `ArticlesController`, but it's up to you.
+  #
+  # Besides, this extension provides with two other methods:
+  #
+  # - `url_helpers` returns Rails router url helpers.
+  # - `helpers` returns the associated controller helpers.
+  #
+  # In all the examples we have supposed that we are putting {WebPipe}
+  # applications within `app/controllers/` directory. However, remember you can
+  # put them wherever you like as long as you respect rails `autoload_paths`.
+  #
+  # Here you have a link to a very simple and contrived example of a rails
+  # application integrating `web_pipe`:
+  #
+  # https://github.com/waiting-for-dev/rails-web_pipe
+  #
+  # @see https://guides.rubyonrails.org/routing.html#routing-to-rack-applications
+  # @see https://dry-rb.org/gems/dry-view/
+  # @see https://github.com/dry-rb/dry-view/tree/master/examples/rails
+  # @see https://waiting-for-dev.github.io/web_pipe/docs/extensions/dry_view.html
+  # @see https://api.rubyonrails.org/v6.0.1/classes/ActionController/Renderer.html
+  # @see https://api.rubyonrails.org/v6.0.1/classes/ActionController/Renderer.html
+  # @see https://api.rubyonrails.org/v6.0.1/classes/ActionView/Helpers/UrlHelper.html
+  # @see https://api.rubyonrails.org/classes/ActionController/Helpers.html
+  # @see https://guides.rubyonrails.org/autoloading_and_reloading_constants.html#autoload-paths
+  module Rails
+    def render(*args)
+      set_response_body(
+        rails_controller.renderer.render(*args)
+      )
+    end
+
+    # @see https://devdocs.io/rails~6.0/actioncontroller/helpers
+    def helpers
+      rails_controller.helpers
+    end
+
+    # @see https://api.rubyonrails.org/v6.0.1/classes/ActionView/Helpers/UrlHelper.html
+    def url_helpers
+      ::Rails.application.routes.url_helpers
+    end
+
+    private
+
+    def rails_controller
+      config.fetch(:rails_controller, ActionController::Base)
+    end
+  end
+
+  Conn.include(Rails)
+end

data/lib/web_pipe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WebPipe
-  VERSION = '0.9.0'
+  VERSION = '0.10.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: web_pipe
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Marc Busqué
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-31 00:00:00.000000000 Z
+date: 2019-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-monads
@@ -244,7 +244,6 @@ files:
 - _config.yml
 - bin/console
 - bin/setup
-- docs/_config.yml
 - docs/building_a_rack_application.md
 - docs/composing_applications.md
 - docs/connection_struct.md
@@ -260,6 +259,7 @@ files:
 - docs/extensions/dry_view.md
 - docs/extensions/flash.md
 - docs/extensions/params.md
+- docs/extensions/rails.md
 - docs/extensions/redirect.md
 - docs/extensions/router_params.md
 - docs/extensions/session.md
@@ -298,6 +298,7 @@ files:
 - lib/web_pipe/extensions/flash/flash.rb
 - lib/web_pipe/extensions/params/params.rb
 - lib/web_pipe/extensions/params/params/transf.rb
+- lib/web_pipe/extensions/rails/rails.rb
 - lib/web_pipe/extensions/redirect/redirect.rb
 - lib/web_pipe/extensions/router_params/router_params.rb
 - lib/web_pipe/extensions/session/session.rb

data/docs/_config.yml

@@ -1 +0,0 @@
-theme: jekyll-theme-slate