web_pipe 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f0e9b6d0efd9e7280bd1628237d3219f1307a28d63ec0d8f0e63366ce93e166
-  data.tar.gz: 407269e3f023e97a84855fe315ca3558ccf49a2b0cb78674336274fb1ae2c800
+  metadata.gz: 846bd7956d65605edaad299346280d7ae4b426d8cf4160e47ebac7375135b4e7
+  data.tar.gz: 41923761b8227c956f6b554bf8dc49fdc6323dc97e08399b5f8b4bc043552fdf
 SHA512:
-  metadata.gz: a2bf1652e9c88e4dcd708b95fc573d1daffeea2f3d56fd908598eb447c1819912c2ac53a35eecf0a5315d4e1195b9c412c34e5a58fb70cf3c5cfa36da602aa45
-  data.tar.gz: 386e1da635847bc21ab2eee5203babda8020fb89f8a11be51e2718bf844e34405ccdb60f4e537d3d3e7afb3d62264f32add6be94711420f490e2f02c3420c9be
+  metadata.gz: b2de9d0a5e7f172e9c42fcf2e97b6ff22046552670c9cf096d270438aab9d572fb4bd915fba282e578f48b39c412ba867d8359881426073b936c9734b3e8a693
+  data.tar.gz: b72848b3ad1e98f18dea9da6b8dc19eef99c61ffb3f71115fd041b1fe699b5ca22bf0395f80e4fd16621d1b72ba8970a1555577126f148ffadf4768ed4a417b4

data/CHANGELOG.md

@@ -4,6 +4,57 @@ 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.4.0] - 2019-07-17
+### Added
+- **BREAKING**: Middlewares have to be named when used ([11](https://github.com/waiting-for-dev/web_pipe/pull/11)):
+
+```ruby
+use :cookies, Rack::Session:Cookie, secret: 'my_secret', key: 'foo'
+```
+
+- **BREAKING**: Middlewares have to be initialized when composed ([11](https://github.com/waiting-for-dev/web_pipe/pull/11)):
+
+```ruby
+use :pipe, PipeWithMiddlewares.new
+```
+
+- **BREAKING**: The array of injected plugs is now scoped within a `plugs:` kwarg ([11](https://github.com/waiting-for-dev/web_pipe/pull/11)):
+
+```ruby
+App.new(plugs: { nothing: ->(conn) { conn } })
+```
+
+- Middlewares can be injected ([11](https://github.com/waiting-for-dev/web_pipe/pull/11)):
+
+```ruby
+App.new(middlewares: { cache: [MyMiddleware, my_options] })
+```
+
+- DSL helper method `compose` to add middlewares and plugs in order and in a single shot ([12](https://github.com/waiting-for-dev/web_pipe/pull/11)):
+
+```ruby
+class App
+  include WebPipe.(container: Container)
+
+  use :first, FirstMiddleware
+
+  plug :first_plug, 'first_plug'
+end
+
+class AnotherApp
+  include WebPipe.(container: Container)
+
+  compose App
+  # Equivalent to:
+  # use App.new
+  # plug &App.new
+
+  use :second, SecondMiddleware
+
+  plug :second_plug, 'second_plug'
+end
+```
+
 ## [0.3.0] - 2019-07-12
 ### Added
 - **BREAKING**: When plugging with `plug:`, the operation is no longer specified through `with:`. Now it is just the second positional argument ([9](https://github.com/waiting-for-dev/web_pipe/pull/9)):
@@ -51,7 +102,7 @@ class App
 end
 ```
 
-- WebPipe's middlewares can be composed into another WebPipe class, also through `:use`:
+- WebPipe's middlewares can be composed into another WebPipe class, also through `:use` ([10](https://github.com/waiting-for-dev/web_pipe/pull/10)):
 
 ```ruby
 class HtmlApp

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    web_pipe (0.2.0)
+    web_pipe (0.3.0)
       dry-initializer (~> 3.0)
       dry-monads (~> 1.2)
       dry-struct (~> 1.0)

data/README.md

@@ -255,8 +255,9 @@ class App
   plug :hello, ->(conn) { conn.set_response_body('Hello') }
 end
 
-run App.new(
-  hello: ->(conn) { conn.set_response_body('Injected') }
+run App.new(plugs: {
+    hello: ->(conn) { conn.set_response_body('Injected') }
+  }
 )
 ```
 
@@ -272,8 +273,8 @@ plugs:
 class App
   include WebPipe
 
-  use Middleware1
-  use Middleware2, option_1: value_1
+  use :middleware_1, Middleware1
+  use :middleware_1, Middleware2, option_1: value_1
 
   plug :hello, ->(conn) { conn }
 end
@@ -286,12 +287,20 @@ class. Extending from previous example:
 class App2
   include WebPipe
 
-  use App # it will also use Middleware1 and Middleware2
+  use :app, App.new # it will also use Middleware1 and Middleware2
 
   plug :hello, ->(conn) { conn }
 end
 ```
 
+Middlewares can also be injected on initialization:
+
+```ruby
+App.new(middlewares: {
+  middleware_1: [AnotherMiddleware, options]
+})
+```
+
 ### Standalone usage
 
 If you prefer, you can use the application builder without the

data/lib/web_pipe/dsl/class_context.rb

@@ -18,7 +18,7 @@ module WebPipe
     # @api private
     class ClassContext < Module
       # Methods to be imported from the {DSLContext}.
-      DSL_METHODS = %i[middlewares use plugs plug].freeze
+      DSL_METHODS = %i[middleware_specifications use plugs plug compose].freeze
 
       # @!attribute [r] container
       # @return [Types::Container[]]

data/lib/web_pipe/dsl/dsl_context.rb

@@ -1,7 +1,6 @@
 require 'dry/initializer'
 require 'web_pipe/types'
 require 'web_pipe/plug'
-require 'web_pipe/rack/middleware'
 require 'web_pipe/rack/middleware_specification'
 
 module WebPipe
@@ -13,36 +12,37 @@ module WebPipe
     #
     # @api private
     class DSLContext
-      # @!attribute middlewares
-      # @return [Array<Rack::Middleware>]
+      # @!attribute middleware_specifications
+      # @return [Array<Rack::MiddlewareSpecifications>]
 
       # @!attribute plugs
       # @return [Array<Plug>]
 
 
       include Dry::Initializer.define -> do
-        param :middlewares,
-              type: Types.Array(Rack::Middleware)
+        param :middleware_specifications,
+              type: Types.Array(Rack::MiddlewareSpecification)
 
         param :plugs,
               type: Types.Array(Plug::Instance)
       end
 
-      # Creates and add rack middlewares to the stack.
+      # Creates and add rack middleware specifications to the stack.
       #
       # The spec can be given in two forms:
       #
       # - As one or two arguments, first one being a
-      # {::Rack::Middleware} class and second one optionally its
+      # rack middleware class and second one optionally its
       # initialization options.
-      # - As a {WebPipe} class, in which case all its rack middlewares
-      # will be added to the stack in order.
+      # - As a {WebPipe} class instance, in which case all its rack
+      # middlewares will be considered.
       #
+      # @param name [Rack::MiddlewareSpecification::Name[]]
       # @param spec [Rack::MiddlewareSpecification::Spec[]]
       #
       # @return [Array<Rack::Middleware>]
-      def use(*spec)
-        middlewares.push(*Rack::MiddlewareSpecification.call(spec))
+      def use(name, *spec)
+        middleware_specifications << Rack::MiddlewareSpecification.new(name, spec)
       end
 
       # Creates and adds a plug to the stack.
@@ -59,6 +59,16 @@ module WebPipe
       def plug(name, spec = nil, &block_spec)
         plugs << Plug.new(name, spec || block_spec)
       end
+
+      # Adds middlewares and plugs from a WebPipe to respective
+      # stacks.
+      #
+      # @param name [Plug::Name[], Middleware::Name[]]
+      # @param spec [WebPipe]
+      def compose(name, spec)
+        use(name, spec)
+        plug(name, &spec)
+      end
     end
   end
 end

data/lib/web_pipe/dsl/instance_methods.rb

@@ -4,6 +4,7 @@ require 'web_pipe/conn'
 require 'web_pipe/app'
 require 'web_pipe/plug'
 require 'web_pipe/rack/app_with_middlewares'
+require 'web_pipe/rack/middleware_specification'
 require 'web_pipe/conn_support/composition'
 
 module WebPipe
@@ -12,8 +13,8 @@ module WebPipe
     #
     # It is from here that you get the rack application you can route
     # to. The initialization phase gives you the chance to inject any
-    # of the plugs, while the instance you get has the `#call` method
-    # expected by rack.
+    # of the plugs or middlewares, while the instance you get has the
+    # `#call` method expected by rack.
     #
     # The pipe state can be accessed through the pipe class, which
     # has been configured through {ClassContext}.
@@ -21,13 +22,20 @@ module WebPipe
     # @api private
     module InstanceMethods
       # No injections at all.
-      EMPTY_INJECTIONS = Types::EMPTY_HASH
+      EMPTY_INJECTIONS = {
+        plugs: Types::EMPTY_HASH,
+        middlewares: Types::EMPTY_HASH
+      }.freeze
 
-      # Type for how plugs should be injected.
-      Injections = Types::Strict::Hash.map(Plug::Name, Plug::Spec)
+      # Type for how plugs and middlewares should be injected.
+      Injections = Types::Strict::Hash.schema(
+        plugs: Plug::Injections,
+        middlewares: Rack::MiddlewareSpecification::Injections
+      )
 
       # @!attribute [r] injections [Injections[]]
-      #   Injected plugs that allow overriding what has been configured.
+      #   Injected plugs and middlewares that allow overriding what
+      # has been configured.
 
 
       include Dry::Initializer.define -> do
@@ -42,11 +50,18 @@ module WebPipe
       # @return [ConnSupport::Composition::Operation[]]
       attr_reader :operations
 
+      # @return [Array<Rack::Middlewares>]
+      attr_reader :middlewares
+
       def initialize(*args)
         super
-        middlewares = self.class.middlewares
         container = self.class.container
-        @operations = Plug.inject_and_resolve(self.class.plugs, injections, container, self)
+        @middlewares = Rack::MiddlewareSpecification.inject_and_resolve(
+          self.class.middleware_specifications, injections[:middlewares]
+        )
+        @operations = Plug.inject_and_resolve(
+          self.class.plugs, injections[:plugs], container, self
+        )
         app = App.new(operations)
         @rack_app = Rack::AppWithMiddlewares.new(middlewares, app)
       end

data/lib/web_pipe/plug.rb

@@ -46,6 +46,13 @@ module WebPipe
     # Type for an instance of self.
     Instance = Types.Instance(self)
 
+    # Schema expected to inject plugs.
+    #
+    # @see #inject_and_resolve
+    Injections = Types::Strict::Hash.map(
+      Plug::Name, Plug::Spec
+    ).default(Types::EMPTY_HASH)
+
     # @!attribute [r] name
     #   @return [Name[]]
 
@@ -89,7 +96,7 @@ module WebPipe
     # Change `plugs` spec's present in `injections` and resolves.
     #
     # @param plugs [Array<Plug>]
-    # @param injections [InstanceMethods::Injections[]]
+    # @param injections [InstanceMethods::PlugInjections[]]
     # @container container [Types::Container[]]
     # @object [Object]
     #

data/lib/web_pipe/rack/middleware_specification.rb

@@ -9,25 +9,75 @@ module WebPipe
     #
     # - As an array where fist element is a rack middleware class
     # while the rest of elements are its initialization options.
-    # - A single element array where it is a class including
-    # {WebPipe}. This specifies all {Rack::Middlewares} configured
+    # - A single element array where it is an instance of a class
+    # including {WebPipe}. This specifies all {Rack::Middlewares}
     # for that {WebPipe}.
     #
     # @api private
-    module MiddlewareSpecification
+    class MiddlewareSpecification
+      # Type for the name given to a middleware.
+      Name = Types::Strict::Symbol.constructor(&:to_sym)
+
+      # Poor type for the specification to resolve a rack middleware.
+      Spec = Types::Strict::Array
+
+      # Schema expected to inject middleware specifications.
+      #
+      # @see #inject_and_resolve
+      Injections = Types::Strict::Hash.map(
+        Rack::MiddlewareSpecification::Name, Rack::MiddlewareSpecification::Spec
+      ).default(Types::EMPTY_HASH)
+
+      # @!attribute [r] name
+      #   @return [Name[]]
+
+      # @!attribute [r] spec
+      #   @return [Spec[]]
+
+
+      include Dry::Initializer.define -> do
+        param :name, Name
+
+        param :spec, Spec
+      end
+
+      # Change spec's present in `injections` and resolves.
+      #
+      # @param middleware_specifications [Array<MiddlewareSpecification>]
+      # @param injections [Injections[]]
+      #
+      # @return [Array<Rack::Middleware>]
+      def self.inject_and_resolve(middleware_specifications, injections)
+        middleware_specifications.map do |spec|
+          if injections.has_key?(spec.name)
+            spec.with(injections[spec.name])
+          else
+            spec
+          end.()
+        end.flatten
+      end
+
       # Resolves {Rack::Middlewares} from given specification.
       #
-      # @param spec [Array]
       # @return [Array<Rack::Middleware>]
-      def self.call(spec)
+      def call
         klass = spec[0]
         options = spec[1..-1] || Types::EMPTY_ARRAY
-        if klass.included_modules.include?(WebPipe)
+        if klass.is_a?(WebPipe)
           klass.middlewares
         elsif klass.is_a?(Class)
           [Middleware.new(middleware: klass, options: options)]
         end
       end
+
+      # Returns new instance with {#spec} replaced.
+      #
+      # @param new_spec [Spec[]]
+      # 
+      # @return [MiddlewareSpecification]
+      def with(new_spec)
+        self.class.new(name, new_spec)
+      end
     end
   end
 end

data/lib/web_pipe/version.rb

@@ -1,3 +1,3 @@
 module WebPipe
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: web_pipe
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Marc Busqué
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-12 00:00:00.000000000 Z
+date: 2019-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack