ibsciss-middleware 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab6d4d8a9225726d9aa68a41d4be42bcac71bc23
-  data.tar.gz: 4df6dce76dca18f51c8af01a3be56e5861d8fe4e
+  metadata.gz: 45a7f568a5dd19fa3ed4060972af8eab369d6cc7
+  data.tar.gz: 9324a50e02d47da8f6a4232db2d0f373dda717f5
 SHA512:
-  metadata.gz: e33e2f98cc16cf4dcf6ee076cf1734b1cf8bac3ef17daf7d8aa97636510d739e4af7f851d0adacb75444844e3c9eba401e5f22c787406adac6badab48ffc7ab4
-  data.tar.gz: c9f1537de72e76797a690c23646640655ca9ed4adfbefae661bef899cac998efb073d199ab9ec3854de9a4cbfa9d4e36322b24d2c201be2530528fcafd9cb734
+  metadata.gz: cc1c0601887f79ce0580705cf7031124315cc25109703765f1b92e66147c8c2ef79b2ee9ffca951ff7bb4ef739bebdf8d21f3ec226fab2630852fa073be45204
+  data.tar.gz: ad2c8c9a03d3da09664e879322906b405423e0fdb8cd801da3fab30c0cfba90ea0529aeeea330a5c1bb4ff28d4922b20f0b61249ab1c7ab57d6d5c161a9dcd94

data/CHANGELOG.md

@@ -1,5 +1,14 @@
+## 0.4.0
+  - Add a name displayed in the logger & inspect methods
+  - Add a logger middleware
+  - Fixed rubocop offenses
+  - Fix builder#inspect to display class name
+
 ## 0.3.2
-  - Add CI & Code Climate & Improve documentation
+  - Add CI, Code Climate, Gitter & Improve documentation
+  - Add `insert_after_each` and `insert_before_each` methods
+  - Improve the `inspect` method to a more readable version
+  - Enable lambda to receive additional arguments
 
 ## 0.3.1
   - Enable lambda to change the given object

data/README.md

@@ -140,18 +140,17 @@ A basic description of the two methods that a middleware must implement:
     state sent in (defined by the caller, but usually a Hash). This call should also
     call `app.call(env)` at some point to move on.
 
-This architecture offers the biggest advantage of letting you enhance the env variable before passing it to the next middleware, 
-and giving you the abilities to change the returned datas, as follow:
+This architecture offers the biggest advantage of letting you enhance the `env` variable before passing it to the next middleware, and giving you the ability to change the returned data, as follows:
 
 ```ruby
 class Greeting
-  def initialize(app, append = nil)
+  def initialize(app, datas = nil)
     @app = app
     @datas = datas
   end
   
   def call(env)
-    env = "#{append} #{env}"
+    env = "#{@datas} #{env}"
     result = @app(env)
     "#{result} !"
   end
@@ -205,6 +204,12 @@ end.call()
 The call method takes an optional parameter which is the state to pass into the
 initial middleware.
 
+You can optionally set a name, that will be displayed in inspect and for logging purpose, for the current middleware:
+
+```ruby
+Middleware::Builder.new(name: 'MyPersonalMiddleware')
+```
+
 ### Manipulating a Stack
 
 Stacks also provide a set of methods for manipulating the middleware stack. This
@@ -254,7 +259,7 @@ stack.insert_before_each logger
 #### Replace
 
 ```ruby
-# Replace the first middleware
+# Replace the second middleware
 stack.replace(1, SomeOtherMiddleware)
 
 # Replace the Trace middleware
@@ -264,7 +269,7 @@ stack.replace(Trace, SomeOtherMiddleware)
 #### Delete
 
 ```ruby
-# Delete the lambda
+# Delete the second middleware
 stack.delete(1)
 
 # Delete the Trace middleware
@@ -304,7 +309,7 @@ Note that you can also pass blocks in using the `use` method.
 
 #### Lambda
 
-Lambda work the same with additional arguments:
+Lambda work the same, with additional arguments:
 
 ```ruby
 Middleware::Builder.new { |b|
@@ -324,8 +329,50 @@ Middleware::Builder.new { |b|
 }.inspect
 ```
 
-the output will be
+It will output:
+
+```ruby
+Middleware[Trace(), Echo("Hello, World!")]
+```
+
+_If you have set a name, it will be displayed instead of `Middleware`_.
+
+#### Logging
+
+A built-in logging mechanism is provided, it will output for each provider of the stack:
+
+- The provided arguments
+- The returned values (the first 255 chars) and the time (in milliseconds) elapsed in the call method
+
+To initialize the logging you must provide a valid logger instance to `#inject_logger`.
+
+It is also recommended to give a name to your middleware stack.
 
 ```ruby
-[Trace(), Echo("Hello, World!")]
-```
+require 'logger'
+
+class UpperCaseMiddleware
+  def initialize app
+    @app = app
+  end
+
+  def call env
+    sleep(1)
+    env.upcase
+  end
+end
+
+# Build the middleware:
+Middleware::Builder.new(name: 'MyMiddleware') { |b|
+    b.use UpperCaseMiddleware
+}.inject_logger(Logger.new(STDOUT)).call('a message')
+```
+
+It will output something like:
+
+```
+INFO -- MyMiddleware: UpperCaseMiddleware has been called with: "a message"
+INFO -- MyMiddleware: UpperCaseMiddleware finished in 1001 ms and returned: "A MESSAGE"
+```
+
+_Note: the provided logger instance must respond to `#call(level severity, message, app name)`_

data/Rakefile

@@ -1,9 +1,9 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 # RSpec test task
 RSpec::Core::RakeTask.new
 
 # Make sure the default is to run RSpec
-task :default => "spec"
+task default: 'spec'

data/lib/middleware.rb

@@ -1,2 +1,2 @@
-require "middleware/builder"
-require "middleware/runner"
+require 'middleware/builder'
+require 'middleware/runner'

data/lib/middleware/builder.rb

@@ -17,6 +17,7 @@ module Middleware
   #     app.call(7)
   #
   class Builder
+
     # Initializes the builder. An optional block can be passed which
     # will either yield the builder or be evaluated in the context of the instance.
     #
@@ -37,9 +38,10 @@ module Middleware
     #   in which knows how to run them.
     # @yield [] Evaluated in this instance which allows you to use methods
     #   like {#use} and such.
-    def initialize(opts=nil, &block)
+    def initialize(opts = nil, &block)
       opts ||= {}
       @runner_class = opts[:runner_class] || Runner
+      @middleware_name = opts[:name] || 'Middleware'
 
       if block_given?
         if block.arity == 1
@@ -50,12 +52,17 @@ module Middleware
       end
     end
 
+    # Returns the name of the current middleware
+    def name
+      @middleware_name
+    end
+
     # Returns a mergeable version of the builder. If `use` is called with
     # the return value of this method, then the stack will merge, instead
     # of being treated as a separate single middleware.
     def flatten
       lambda do |env|
-        self.call(env)
+        call(env)
       end
     end
 
@@ -65,11 +72,11 @@ module Middleware
     #
     # @param [Class] middleware The middleware class
     def use(middleware, *args, &block)
-      if middleware.kind_of?(Builder)
+      if middleware.is_a?(Builder)
         # Merge in the other builder's stack into our own
-        self.stack.concat(middleware.stack)
+        stack.concat(middleware.stack)
       else
-        self.stack << [middleware, args, block]
+        stack << [middleware, args, block]
       end
 
       self
@@ -79,7 +86,7 @@ module Middleware
     # given middleware object.
     def insert(index, middleware, *args, &block)
       index = self.index(index) unless index.is_a?(Integer)
-      raise "no such middleware to insert before: #{index.inspect}" unless index
+      fail "no such middleware to insert before: #{index.inspect}" unless index
       stack.insert(index, [middleware, args, block])
     end
 
@@ -88,7 +95,7 @@ module Middleware
     # Inserts a middleware after the given index or middleware object.
     def insert_after(index, middleware, *args, &block)
       index = self.index(index) unless index.is_a?(Integer)
-      raise "no such middleware to insert after: #{index.inspect}" unless index
+      fail "no such middleware to insert after: #{index.inspect}" unless index
       insert(index + 1, middleware, *args, &block)
     end
 
@@ -125,14 +132,22 @@ module Middleware
     end
 
     # Runs the builder stack with the given environment.
-    def call(env=nil)
+    def call(env = nil)
       to_app.call(env)
     end
 
     def inspect
-      "[" + stack.reduce([]) { |carry, middleware|
-        carry << "#{middleware[0].class.name}(#{middleware[1].join(', ')})"
-      }.join(', ') + "]"
+      name+'[' + stack.reduce([]) do |carry, middleware|
+        name = middleware[0].is_a?(Proc) ? 'Proc' : middleware[0].name
+
+        carry << "#{name}(#{middleware[1].join(', ')})"
+      end.join(', ') + ']'
+    end
+
+    def inject_logger logger
+      insert_before_each Middleware::Logger, logger, name
+
+      self
     end
 
     protected
@@ -160,9 +175,7 @@ module Middleware
     # you shouldn't use this method
     #
     # @return [Array]
-    def stack= stack
-      @stack = stack
-    end
+    attr_writer :stack
 
     # Converts the builder stack to a runnable action sequence.
     #
@@ -170,6 +183,5 @@ module Middleware
     def to_app
       @runner_class.new(stack.dup)
     end
-
   end
 end

data/lib/middleware/logger.rb

@@ -0,0 +1,49 @@
+require 'logger'
+require 'pp'
+
+module Middleware
+
+  class Logger
+    def initialize app, logger, name = nil
+      @app = app
+      @write_to = logger
+      @middleware_name = name
+    end
+
+    def call env
+      write(
+          way_in_message(
+              next_middleware_name, env
+      ))
+
+      time = Time.now
+
+      @app.call(env).tap { |env|
+        write(
+            way_out_message(
+                next_middleware_name, (Time.now - time) * 1000.0, env
+        ))
+      }
+    end
+
+    def next_middleware_name
+      @app.class.name
+    end
+
+    def pretty_print item
+      ->(out){ PP.pp(item, out) }.('')
+    end
+
+    def way_in_message name, env
+      ' %s has been called with: %s' % [name, pretty_print(env)]
+    end
+
+    def way_out_message name, time, value
+      ' %s finished in %.0f ms and returned: %s' % [name, time, pretty_print(value)]
+    end
+
+    def write msg
+      @write_to.add(::Logger::INFO, msg.slice(0, 255).strip!, @middleware_name)
+    end
+  end
+end

data/lib/middleware/runner.rb

@@ -4,7 +4,7 @@ module Middleware
   # in order, then reversing the order.
   class Runner
     # A middleware which does nothing
-    EMPTY_MIDDLEWARE = lambda { |env| env }
+    EMPTY_MIDDLEWARE = ->(env) { env }
 
     # Build a new middleware runner with the given middleware
     # stack.
@@ -60,7 +60,7 @@ module Middleware
             next_middleware.call(klass.call(env, *args))
           end
         else
-          raise "Invalid middleware, doesn't respond to `call`: #{klass.inspect}"
+          fail "Invalid middleware, doesn't respond to `call`: #{klass.inspect}"
         end
       end
     end

data/middleware.gemspec

@@ -1,23 +1,23 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Mitchell Hashimoto", "Arnaud Lemaire"]
-  gem.email         = ["mitchell.hashimoto@gmail.com", "alemaire@ibsciss.com"]
-  gem.description   = %q{Generalized implementation of the rack middleware abstraction for Ruby.}
-  gem.summary       = %q{Generalized implementation of the rack middleware abstraction for Ruby (chain of responsibility design pattern).}
-  gem.homepage      = "https://github.com/ibsciss/ruby-middleware"
-  gem.license       = "MIT"
+  gem.authors       = ['Mitchell Hashimoto', 'Arnaud Lemaire']
+  gem.email         = ['mitchell.hashimoto@gmail.com', 'alemaire@ibsciss.com']
+  gem.description   = 'Generalized implementation of the rack middleware abstraction for Ruby.'
+  gem.summary       = 'Generalized implementation of the rack middleware abstraction for Ruby (chain of responsibility design pattern).'
+  gem.homepage      = 'https://github.com/ibsciss/ruby-middleware'
+  gem.license       = 'MIT'
 
-  gem.add_development_dependency "rake", "~> 10.4.2"
-  gem.add_development_dependency "rspec-core", "~> 3.2"
-  gem.add_development_dependency "rspec-expectations", "~> 3.2"
-  gem.add_development_dependency "rspec-mocks", "~> 3.2"
+  gem.add_development_dependency 'rake', '~> 10.4.2'
+  gem.add_development_dependency 'rspec-core', '~> 3.2'
+  gem.add_development_dependency 'rspec-expectations', '~> 3.2'
+  gem.add_development_dependency 'rspec-mocks', '~> 3.2'
   gem.add_development_dependency 'codeclimate-test-reporter', '~> 0.4.7'
 
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.name          = "ibsciss-middleware"
-  gem.require_paths = ["lib"]
-  gem.version       = '0.3.2'
+  gem.name          = 'ibsciss-middleware'
+  gem.require_paths = ['lib']
+  gem.version       = '0.4.0'
 end

data/spec/middleware/builder_spec.rb

@@ -1,20 +1,20 @@
-require "middleware"
+require 'middleware'
 
 describe Middleware::Builder do
-  let(:data) { { :data => [] } }
+  let(:data) { { data: [] } }
   let(:instance) { described_class.new }
 
   # This returns a proc that can be used with the builder
   # that simply appends data to an array in the env.
   def appender_proc(data)
-    Proc.new { |obj| obj.tap { |env| env[:data] << data }}
+    proc { |obj| obj.tap { |env| env[:data] << data } }
   end
 
-  context "initialized with a block" do
-    context "without explicit receiver" do
-      it "instance evals the block" do
+  context 'initialized with a block' do
+    context 'without explicit receiver' do
+      it 'instance evals the block' do
         data = {}
-        proc = Proc.new { |env| env[:data] = true }
+        proc = proc { |env| env[:data] = true }
 
         app = described_class.new do
           use proc
@@ -26,10 +26,10 @@ describe Middleware::Builder do
       end
     end
 
-    context "with explicit receiver" do
-      it "yields self to the block" do
+    context 'with explicit receiver' do
+      it 'yields self to the block' do
         data = {}
-        proc = Proc.new { |env| env[:data] = true }
+        proc = proc { |env| env[:data] = true }
 
         app = described_class.new do |b|
           b.use proc
@@ -42,10 +42,10 @@ describe Middleware::Builder do
     end
   end
 
-  context "basic `use`" do
-    it "should add items to the stack and make them callable" do
+  context 'basic `use`' do
+    it 'should add items to the stack and make them callable' do
       data = {}
-      proc = Proc.new { |env| env[:data] = true }
+      proc = proc { |env| env[:data] = true }
 
       instance.use proc
       instance.call(data)
@@ -53,10 +53,10 @@ describe Middleware::Builder do
       expect(data[:data]).to be_truthy
     end
 
-    it "should be able to add multiple items" do
+    it 'should be able to add multiple items' do
       data = {}
-      proc1 = Proc.new { |env| env.tap { |obj| obj[:one] = true }}
-      proc2 = Proc.new { |env| env.tap { |obj| obj[:two] = true }}
+      proc1 = proc { |env| env.tap { |obj| obj[:one] = true } }
+      proc2 = proc { |env| env.tap { |obj| obj[:two] = true } }
 
       instance.use proc1
       instance.use proc2
@@ -66,16 +66,16 @@ describe Middleware::Builder do
       expect(data[:two]).to be_truthy
     end
 
-    it "should be able to add another builder" do
+    it 'should be able to add another builder' do
       data  = {}
-      proc1 = Proc.new { |env| env[:one] = true }
+      proc1 = proc { |env| env[:one] = true }
 
       # Build the first builder
       one   = described_class.new
       one.use proc1
 
       # Add it to this builder
-      two   = described_class.new
+      two = described_class.new
       two.use one
 
       # Call the 2nd and verify results
@@ -83,19 +83,19 @@ describe Middleware::Builder do
       expect(data[:one]).to be_truthy
     end
 
-    it "should default the env to `nil` if not given" do
+    it 'should default the env to `nil` if not given' do
       result = false
-      proc = Proc.new { |env| result = env.nil? }
+      proc = proc { |env| result = env.nil? }
 
       instance.use proc
       instance.call
 
       expect(result).to be_truthy
-     end
+    end
   end
 
-  context "inserting" do
-    it "can insert at an index" do
+  context 'inserting' do
+    it 'can insert at an index' do
       instance.use appender_proc(1)
       instance.insert(0, appender_proc(2))
       instance.call(data)
@@ -103,7 +103,7 @@ describe Middleware::Builder do
       expect(data[:data]).to eq [2, 1]
     end
 
-    it "can insert next to a previous object" do
+    it 'can insert next to a previous object' do
       proc2 = appender_proc(2)
       instance.use appender_proc(1)
       instance.use proc2
@@ -113,7 +113,7 @@ describe Middleware::Builder do
       expect(data[:data]).to eq [1, 3, 2]
     end
 
-    it "can insert before" do
+    it 'can insert before' do
       instance.use appender_proc(1)
       instance.insert_before 0, appender_proc(2)
       instance.call(data)
@@ -121,12 +121,12 @@ describe Middleware::Builder do
       expect(data[:data]).to eq [2, 1]
     end
 
-    it "raises an exception if attempting to insert before an invalid object" do
-      expect { instance.insert "object", appender_proc(1) }.
-        to raise_error(RuntimeError)
+    it 'raises an exception if attempting to insert before an invalid object' do
+      expect { instance.insert 'object', appender_proc(1) }
+        .to raise_error(RuntimeError)
     end
 
-    it "can insert after each" do
+    it 'can insert after each' do
       instance.use appender_proc(1)
       instance.use appender_proc(2)
       instance.use appender_proc(3)
@@ -135,7 +135,7 @@ describe Middleware::Builder do
       expect(data[:data]).to eq [1, 9, 2, 9, 3, 9]
     end
 
-    it "can insert before each" do
+    it 'can insert before each' do
       instance.use appender_proc(1)
       instance.use appender_proc(2)
       instance.use appender_proc(3)
@@ -144,14 +144,14 @@ describe Middleware::Builder do
       expect(data[:data]).to eq [9, 1, 9, 2, 9, 3]
     end
 
-    it "raises an exception if attempting to insert after an invalid object" do
-      expect { instance.insert_after "object", appender_proc(1) }.
-        to raise_error(RuntimeError)
+    it 'raises an exception if attempting to insert after an invalid object' do
+      expect { instance.insert_after 'object', appender_proc(1) }
+        .to raise_error(RuntimeError)
     end
   end
 
-  context "replace" do
-    it "can replace an object" do
+  context 'replace' do
+    it 'can replace an object' do
       proc1 = appender_proc(1)
       proc2 = appender_proc(2)
 
@@ -162,7 +162,7 @@ describe Middleware::Builder do
       expect(data[:data]).to eq [2]
     end
 
-    it "can replace by index" do
+    it 'can replace by index' do
       proc1 = appender_proc(1)
       proc2 = appender_proc(2)
 
@@ -174,8 +174,8 @@ describe Middleware::Builder do
     end
   end
 
-  context "deleting" do
-    it "can delete by object" do
+  context 'deleting' do
+    it 'can delete by object' do
       proc1 = appender_proc(1)
 
       instance.use proc1
@@ -186,7 +186,7 @@ describe Middleware::Builder do
       expect(data[:data]).to eq [2]
     end
 
-    it "can delete by index" do
+    it 'can delete by index' do
       proc1 = appender_proc(1)
 
       instance.use proc1
@@ -198,11 +198,45 @@ describe Middleware::Builder do
     end
   end
 
-  context "debugging" do
-    it "has an inspect method" do
+  context 'debugging' do
+    class Echo
+      def initialize app
+        @app = app
+      end
+
+      def call env
+        @app.call(env)
+      end
+    end
+
+    it 'has an inspect method' do
       instance.use appender_proc(1)
       instance.use appender_proc(1), 2
-      expect(instance.inspect).to eq '[Proc(), Proc(2)]'
+      instance.use Echo, 'Hi, how are you?'
+      expect(instance.inspect).to eq 'Middleware[Proc(), Proc(2), Echo(Hi, how are you?)]'
+    end
+
+    it 'displays his name in the inspect' do
+      middleware = described_class.new(name: 'Dumb') { |b|
+        b.use appender_proc(1)
+      }
+      expect(middleware.inspect).to eq 'Dumb[Proc()]'
+    end
+
+    it "can have a name" do
+      expect(described_class.new(name: 'Name').name).to eq 'Name'
+    end
+
+    it "can have a Logger" do
+      mocked_logger = instance_double(Logger)
+      expect(mocked_logger).to receive(:add).exactly(4).times
+
+      described_class.new(name: 'Dumb') { |b|
+        b.use Echo
+        b.use Echo
+      }.inject_logger(mocked_logger)
+       .call()
     end
   end
-end
+
+end

data/spec/middleware/logger_spec.rb

@@ -0,0 +1,58 @@
+require_relative '../../lib/middleware/logger'
+require 'logger'
+
+class NEXT_Middleware
+  def initialize app
+    @app = app
+  end
+
+  def call env
+    env
+  end
+end
+
+#Middleware.new('tchoutchou_orchestrator') {
+#}.inject_logger(Logger.new IO::String(''))
+
+describe Middleware::Logger do
+
+  it 'wrote the names of the next middleware in the logger' do
+    mocked_logger = instance_double('Logger');
+    expect(mocked_logger).to receive(:add).twice
+
+    described_class.new(NEXT_Middleware.new(nil), mocked_logger, 'dump_middleware').call(1)
+  end
+
+  describe '#next_middleware_name' do
+    context 'when the next middleware is a Class' do
+      it 'extracts the next middleware name from the class name' do
+        expect(described_class.new(NEXT_Middleware.new(nil), nil).next_middleware_name).to eq 'NEXT_Middleware'
+      end
+    end
+
+    context 'when the next middleware is a Lambda' do
+      it 'gives "Proc" for the next middleware' do
+        expect(described_class.new(->(env){env}, nil).next_middleware_name).to eq 'Proc'
+      end
+    end
+  end
+
+  describe '#way_out_message' do
+    it 'returns a formatted message' do
+      expect(described_class.new(nil, nil).way_out_message('Dumb', 2400, [1, 2])).to eq " Dumb finished in 2400 ms and returned: [1, 2]\n"
+    end
+  end
+
+  describe '#way_in_message' do
+    it 'returns a formatted message' do
+      expect(described_class.new(nil, nil).way_in_message('Dumb', [1, 2])).to eq " Dumb has been called with: [1, 2]\n"
+    end
+  end
+
+  describe '#pretty_print' do
+    it 'pretty prints given var' do
+      expect(described_class.new(nil, nil).pretty_print([1, 2, 3, 4, 5])).to eq "[1, 2, 3, 4, 5]\n"
+    end
+  end
+
+end

data/spec/middleware/runner_spec.rb

@@ -1,21 +1,21 @@
-require "middleware"
+require 'middleware'
 
 describe Middleware::Runner do
-  it "should work with an empty stack" do
+  it 'should work with an empty stack' do
     instance = described_class.new([])
     expect { instance.call({}) }.to_not raise_error
   end
 
-  it "should call classes in the proper order" do
+  it 'should call classes in the proper order' do
     a = Class.new do
       def initialize(app)
         @app = app
       end
 
       def call(env)
-        env[:result] << "A"
+        env[:result] << 'A'
         @app.call(env)
-        env[:result] << "A"
+        env[:result] << 'A'
       end
     end
 
@@ -25,40 +25,40 @@ describe Middleware::Runner do
       end
 
       def call(env)
-        env[:result] << "B"
+        env[:result] << 'B'
         @app.call(env)
-        env[:result] << "B"
+        env[:result] << 'B'
       end
     end
 
-    env = { :result => [] }
+    env = { result: [] }
     instance = described_class.new([a, b])
     instance.call(env)
-    expect(env[:result]).to eq ["A", "B", "B", "A"]
+    expect(env[:result]).to eq %w(A B B A)
   end
 
-  it "should call lambdas in the proper order" do
+  it 'should call lambdas in the proper order' do
     data = []
-    a = lambda { |env| data << "A" }
-    b = lambda { |env| data << "B" }
+    a = ->(_env) { data << 'A' }
+    b = ->(_env) { data << 'B' }
 
     instance = described_class.new([a, b])
     instance.call({})
 
-    expect(data).to eq ["A", "B"]
+    expect(data).to eq %w(A B)
   end
 
-  it "should let lambdas to change the given argument" do
-    a = lambda { |env| env + 1 }
-    b = lambda { |env| env + 2 }
+  it 'should let lambdas to change the given argument' do
+    a = ->(env) { env + 1 }
+    b = ->(env) { env + 2 }
 
     instance = described_class.new([a, b])
     expect(instance.call(1)).to eq 4
   end
 
-  it "passes in arguments to lambda if given" do
+  it 'passes in arguments to lambda if given' do
     data = []
-    a = lambda { |env, arg| data << arg }
+    a = ->(_env, arg) { data << arg }
 
     instance = described_class.new([[a, 1]])
     instance.call(nil)
@@ -66,7 +66,7 @@ describe Middleware::Runner do
     expect(data).to eq [1]
   end
 
-  it "passes in arguments if given" do
+  it 'passes in arguments if given' do
     a = Class.new do
       def initialize(app, value)
         @app   = app
@@ -85,9 +85,9 @@ describe Middleware::Runner do
     expect(env[:result]).to eq 42
   end
 
-  it "passes in a block if given" do
+  it 'passes in a block if given' do
     a = Class.new do
-      def initialize(app, &block)
+      def initialize(_app, &block)
         @block = block
       end
 
@@ -96,7 +96,7 @@ describe Middleware::Runner do
       end
     end
 
-    block = Proc.new { 42 }
+    block = proc { 42 }
     env = {}
     instance = described_class.new([[a, nil, block]])
     instance.call(env)
@@ -104,7 +104,7 @@ describe Middleware::Runner do
     expect(env[:result]).to eq 42
   end
 
-  it "should raise an error if an invalid middleware is given" do
+  it 'should raise an error if an invalid middleware is given' do
     expect { described_class.new([27]) }.to raise_error(/Invalid middleware/)
   end
 
@@ -112,24 +112,26 @@ describe Middleware::Runner do
     # A does not call B, so B should never execute
     data = []
     a = Class.new do
-      def initialize(app); @app = app; end
+      def initialize(app)
+        @app = app
+      end
 
-      define_method :call do |env|
-        data << "a"
+      define_method :call do |_env|
+        data << 'a'
       end
     end
 
-    b = lambda { |env| data << "b" }
+    b = ->(_env) { data << 'b' }
 
     env = {}
     instance = described_class.new([a, b])
     instance.call(env)
 
-    expect(data).to eq ["a"]
+    expect(data).to eq ['a']
   end
 
-  describe "exceptions" do
-    it "should propagate the exception up the middleware chain" do
+  describe 'exceptions' do
+    it 'should propagate the exception up the middleware chain' do
       # This tests a few important properties:
       # * Exceptions propagate multiple middlewares
       #   - C raises an exception, which raises through B to A.
@@ -141,70 +143,76 @@ describe Middleware::Runner do
         end
 
         define_method :call do |env|
-          data << "a"
+          data << 'a'
           begin
             @app.call(env)
-            data << "never"
+            data << 'never'
           rescue Exception => e
-            data << "e"
+            data << 'e'
             raise
           end
         end
       end
 
       b = Class.new do
-        def initialize(app); @app = app; end
+        def initialize(app)
+          @app = app
+        end
 
         define_method :call do |env|
-          data << "b"
+          data << 'b'
           @app.call(env)
         end
       end
 
-      c = lambda { |env| raise "ERROR" }
+      c = ->(_env) { fail 'ERROR' }
 
       env = {}
       instance = described_class.new([a, b, c])
       expect { instance.call(env) }.to raise_error 'ERROR'
 
-      expect(data).to eq ["a", "b", "e"]
+      expect(data).to eq %w(a b e)
     end
 
-    it "should stop propagation if rescued" do
+    it 'should stop propagation if rescued' do
       # This test mainly tests that if there is a sequence A, B, C, and
       # an exception is raised in C, that if B rescues this, then the chain
       # continues fine backwards.
       data = []
       a = Class.new do
-        def initialize(app); @app = app; end
+        def initialize(app)
+          @app = app
+        end
 
         define_method :call do |env|
-          data << "in_a"
+          data << 'in_a'
           @app.call(env)
-          data << "out_a"
+          data << 'out_a'
         end
       end
 
       b = Class.new do
-        def initialize(app); @app = app; end
+        def initialize(app)
+          @app = app
+        end
 
         define_method :call do |env|
-          data << "in_b"
+          data << 'in_b'
           @app.call(env) rescue nil
-          data << "out_b"
+          data << 'out_b'
         end
       end
 
-      c = lambda do |env|
-        data << "in_c"
-        raise "BAD"
+      c = lambda do |_env|
+        data << 'in_c'
+        fail 'BAD'
       end
 
       env = {}
       instance = described_class.new([a, b, c])
       instance.call(env)
 
-      expect(data).to eq ["in_a", "in_b", "in_c", "out_b", "out_a"]
+      expect(data).to eq %w(in_a in_b in_c out_b out_a)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-require "codeclimate-test-reporter"
+require 'codeclimate-test-reporter'
 CodeClimate::TestReporter.start
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
@@ -42,50 +42,48 @@ RSpec.configure do |config|
 
   # The settings below are suggested to provide a good initial experience
   # with RSpec, but feel free to customize to your heart's content.
-=begin
-  # These two settings work together to allow you to limit a spec run
-  # to individual examples or groups you care about by tagging them with
-  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
-  # get run.
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  # Limits the available syntax to the non-monkey patched syntax that is recommended.
-  # For more details, see:
-  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
-  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
-  config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = 'doc'
-  end
-
-  # Print the 10 slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  config.profile_examples = 10
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-=end
+  #   # These two settings work together to allow you to limit a spec run
+  #   # to individual examples or groups you care about by tagging them with
+  #   # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  #   # get run.
+  #   config.filter_run :focus
+  #   config.run_all_when_everything_filtered = true
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  #   # For more details, see:
+  #   #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  #   config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  #   if config.files_to_run.one?
+  #     # Use the documentation formatter for detailed output,
+  #     # unless a formatter has already been configured
+  #     # (e.g. via a command-line flag).
+  #     config.default_formatter = 'doc'
+  #   end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # Run specs in random order to surface order dependencies. If you find an
+  #   # order dependency and want to debug it, you can fix the order by providing
+  #   # the seed, which is printed after each run.
+  #   #     --seed 1234
+  #   config.order = :random
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  #   Kernel.srand config.seed
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ibsciss-middleware
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Mitchell Hashimoto
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-21 00:00:00.000000000 Z
+date: 2015-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -98,9 +98,11 @@ files:
 - Rakefile
 - lib/middleware.rb
 - lib/middleware/builder.rb
+- lib/middleware/logger.rb
 - lib/middleware/runner.rb
 - middleware.gemspec
 - spec/middleware/builder_spec.rb
+- spec/middleware/logger_spec.rb
 - spec/middleware/runner_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ibsciss/ruby-middleware
@@ -130,5 +132,6 @@ summary: Generalized implementation of the rack middleware abstraction for Ruby
   of responsibility design pattern).
 test_files:
 - spec/middleware/builder_spec.rb
+- spec/middleware/logger_spec.rb
 - spec/middleware/runner_spec.rb
 - spec/spec_helper.rb