meddleware 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 453a4fea42903735f1b7e502f5fb5ba323ecfd1240db7d476453dabd0e773f8d
-  data.tar.gz: c459598e2a9145a7ad8a4128cefc5de8ed3a018db28e1cf95a24a26b15b42883
+  metadata.gz: 3bfe09bf6e8d403864543e0c74fea482608b78f31c83b32a6cca71ad1d8a3973
+  data.tar.gz: 93c888f10763f70779e9a834249e475f6eab18db3f2eacf9bd1442cb87f155d4
 SHA512:
-  metadata.gz: 94db19316854023dece52b027bd87f0c423936c3ccf4fba424b85eaa798672aa936820ecb0b5e427c5832c29fe7deb6dce876563c70c3869b15b1b137d26b511
-  data.tar.gz: 57188689d33ca8a987e4cdcde3792da430b86946c6c0ec99ace62b6e7be05c9658eacbc83f6e3cc26c20d3c8e06a47ef53fa4937919d7d4c1e49a556469cc0c3
+  metadata.gz: abaee8a6faafe5ed08d04d9a5166efedbf3e9cc51de2fc3bd1608ba57496e38676860b18bc44ab4a8dfc4030709fc287c84cfaa5001be7a391be7f5f09f4b736
+  data.tar.gz: 5222b652ae8a45723d4b20798d4c852d7b8a0e24a1449531c0c8fc96a3c3fa3a265e4bbe8bec3e81f1958a77112fd189f8a75b9bce2f66f3c4c8e5ae8770dac3

data/lib/meddleware/v2_5.rb

@@ -0,0 +1,143 @@
+# backwards compatible functionality for Ruby 2.5
+
+class Meddleware
+  module V2_5
+    def use(*klass_and_args, &block)
+      entry = create_entry(klass_and_args, block)
+      remove(entry[0])
+      stack << entry
+      self
+    end
+    alias append use
+
+    def prepend(*klass_and_args, &block)
+      entry = create_entry(klass_and_args, block)
+      remove(entry[0])
+      stack.insert(0, entry)
+      self
+    end
+
+    def after(after_klass, *klass_and_args, &block)
+      entry = create_entry(klass_and_args, block)
+      remove(entry[0])
+
+      i = if after_klass.is_a? Array
+        after_klass.map {|x| index(x) }.compact.max
+      else
+        index(after_klass)
+      end
+      i ||= count - 1 # last element
+
+      stack.insert(i + 1, entry)
+      self
+    end
+
+    def before(before_klass, *klass_and_args, &block)
+      entry = create_entry(klass_and_args, block)
+      remove(entry[0])
+
+      i = if before_klass.is_a? Array
+        before_klass.map {|x| index(x) }.compact.min
+      else
+        index(before_klass)
+      end
+      i ||= 0 # first element
+
+      stack.insert(i, entry)
+      self
+    end
+
+    def replace(old_klass, *klass_and_args, &block)
+      entry = create_entry(klass_and_args, block)
+      remove(entry[0])
+
+      i = index(old_klass)
+
+      unless i
+        raise RuntimeError, "middleware not present: #{old_klass}"
+      end
+
+      stack[i] = entry
+      self
+    end
+
+    def call(*args)
+      chain = build_chain
+      default_args = args
+
+      traverse = proc do |*args|
+        if args.empty?
+          args = default_args
+        else
+          default_args = args
+        end
+
+        if chain.empty?
+          yield(*args) if block_given?
+        else
+          middleware = chain.shift
+
+          if middleware.is_a?(Proc) && !middleware.lambda?
+            middleware.call(*args)
+
+            # implicit yield
+            traverse.call(*args)
+          else
+            middleware.call(*args, &traverse)
+          end
+        end
+      end
+      traverse.call(*args)
+    end
+
+
+    private
+
+    def create_entry(klass_and_args, block)
+      klass, *args = klass_and_args
+
+      if [ klass, block ].compact.count == 0
+        raise ArgumentError, 'either a middleware or block must be provided'
+      end
+
+      if klass
+        # validate
+        if klass.is_a? Class
+          unless klass.method_defined?(:call)
+            raise ArgumentError, "middleware must implement `.call`: #{klass}"
+          end
+        else
+          unless klass.respond_to?(:call)
+            raise ArgumentError, "middleware must respond to `.call`: #{klass}"
+          end
+
+          unless block.nil?
+            raise ArgumentError, 'can not supply middleware instance and block'
+          end
+        end
+
+        [ klass, args, block ].compact
+      else
+        [ block ]
+      end
+    end
+
+    def build_chain
+      # build the middleware stack
+      stack.map do |klass, args, block|
+        if klass.is_a? Class
+          klass.new(*args, &block)
+        else
+          if args.nil? || args.empty?
+            klass
+          else
+            # curry args
+            ->(*more_args, &block) do
+              klass.call(*args, *more_args, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/meddleware/version.rb

@@ -1,3 +1,3 @@
 class Meddleware
-  VERSION = '0.1.0'
+  VERSION = "0.2.0"
 end

data/lib/meddleware.rb

@@ -5,44 +5,64 @@ class Meddleware
     instance_eval(&block) if block_given?
   end
 
-  def use(*klass_and_args, &block)
-    entry = create_entry(klass_and_args, block)
+  def use(*args, **kwargs, &block)
+    entry = create_entry(args, kwargs, block)
+    remove(entry[0])
     stack << entry
     self
   end
   alias append use
 
-  def prepend(*klass_and_args, &block)
-    entry = create_entry(klass_and_args, block)
+  def prepend(*args, **kwargs, &block)
+    entry = create_entry(args, kwargs, block)
+    remove(entry[0])
     stack.insert(0, entry)
     self
   end
 
-  def after(after_klass, *klass_and_args, &block)
-    entry = create_entry(klass_and_args, block)
-    i = index(after_klass) || count - 1
+  def after(after_klass, *args, **kwargs, &block)
+    entry = create_entry(args, kwargs, block)
+    remove(entry[0])
+
+    i = if after_klass.is_a? Array
+      after_klass.map {|x| index(x) }.compact.max
+    else
+      index(after_klass)
+    end
+    i ||= count - 1 # last element
+
     stack.insert(i + 1, entry)
     self
   end
 
-  def before(before_klass, *klass_and_args, &block)
-    entry = create_entry(klass_and_args, block)
-    i = index(before_klass) || 0
+  def before(before_klass, *args, **kwargs, &block)
+    entry = create_entry(args, kwargs, block)
+    remove(entry[0])
+
+    i = if before_klass.is_a? Array
+      before_klass.map {|x| index(x) }.compact.min
+    else
+      index(before_klass)
+    end
+    i ||= 0 # first element
+
     stack.insert(i, entry)
     self
   end
 
-  def include?(klass)
-    !!index(klass)
+  def include?(*klass)
+    klass.all? {|x| index(x) }
   end
 
-  def remove(klass)
-    stack.reject! { |entry| entry[0] == klass }
+  def remove(*klass)
+    stack.reject! { |entry| klass.include?(entry[0]) }
     self
   end
 
-  def replace(old_klass, *klass_and_args, &block)
-    entry = create_entry(klass_and_args, block)
+  def replace(old_klass, *args, **kwargs, &block)
+    entry = create_entry(args, kwargs, block)
+    remove(entry[0])
+
     i = index(old_klass)
 
     unless i
@@ -66,37 +86,41 @@ class Meddleware
     stack.empty?
   end
 
-  def call(*args)
+  def call(*args, **kwargs)
     chain = build_chain
     default_args = args
+    default_kwargs = kwargs
 
-    traverse = proc do |*args|
-      if args.empty?
+    traverse = proc do |*args, **kwargs|
+      if args.empty? && kwargs.empty?
         args = default_args
+        kwargs = default_kwargs
       else
         default_args = args
+        default_kwargs = kwargs
       end
 
       if chain.empty?
-        yield(*args) if block_given?
+        yield(*args, **kwargs) if block_given?
       else
         middleware = chain.shift
 
         if middleware.is_a?(Proc) && !middleware.lambda?
-          middleware.call(*args)
+          middleware.call(*args, **kwargs)
 
           # implicit yield
-          traverse.call(*args)
+          traverse.call(*args, **kwargs)
         else
-          middleware.call(*args, &traverse)
+          middleware.call(*args, **kwargs, &traverse)
         end
       end
     end
-    traverse.call(*args)
+
+    traverse.call(*args, **kwargs)
   end
 
 
-  private
+  protected
 
   def stack
     @stack ||= []
@@ -106,16 +130,13 @@ class Meddleware
     stack.index {|entry| entry[0] == klass }
   end
 
-  def create_entry(klass_and_args, block)
-    klass, *args = klass_and_args
+  def create_entry(args, kwargs, block)
+    klass, *args = args
 
-    if [ klass, block ].compact.count == 0
+    if [ klass, block ].compact.empty?
       raise ArgumentError, 'either a middleware or block must be provided'
     end
 
-    # dedup
-    remove(klass || block)
-
     if klass
       # validate
       if klass.is_a? Class
@@ -132,7 +153,7 @@ class Meddleware
         end
       end
 
-      [ klass, args, block ]
+      [ klass, args, kwargs, block ].compact
     else
       [ block ]
     end
@@ -140,19 +161,32 @@ class Meddleware
 
   def build_chain
     # build the middleware stack
-    stack.map do |klass, args, block|
+    stack.map do |klass, args, kwargs, block|
       if klass.is_a? Class
-        klass.new(*args, &block)
+        klass.new(*args, **kwargs, &block)
       else
-        if args.nil? || args.empty?
+        if args.nil? && kwargs.nil?
+          # middleware is a block
+          klass
+        elsif args.empty? && kwargs.empty?
+          # nothing to curry, just pass through middleware instance
           klass
         else
           # curry args
-          ->(*more_args, &block) do
-            klass.call(*args, *more_args, &block)
+          ->(*more_args, **more_kwargs, &block) do
+            klass.call(
+              *(args + more_args),
+              **kwargs.merge(more_kwargs),
+              &block
+            )
           end
         end
       end
     end
   end
+
+  if RUBY_VERSION < '3'
+    require 'meddleware/v2_5'
+    prepend Meddleware::V2_5
+  end
 end

data/spec/build_meddleware_spec.rb

@@ -200,6 +200,33 @@ describe Meddleware do
       subject.after nil, C
       expect(stack).to eq [ A, C ]
     end
+
+    context 'when target is an array' do
+      before do
+        subject.use A
+        subject.use B
+      end
+
+      it 'inserts after the last target' do
+        subject.after [ A, B ], C
+        expect(stack).to eq [ A, B, C ]
+      end
+
+      it 'ignores missing targets' do
+        subject.after [ A, Meddler ], C
+        expect(stack).to eq [ A, C, B ]
+      end
+
+      it 'handles nil targets' do
+        subject.after [ nil, A ], C
+        expect(stack).to eq [ A, C, B ]
+      end
+
+      it 'handles an empty array' do
+        subject.after [], C
+        expect(stack).to eq [ A, B, C ]
+      end
+    end
   end
 
   describe '#before' do
@@ -231,6 +258,33 @@ describe Meddleware do
       subject.before nil, C
       expect(stack).to eq [ C, A ]
     end
+
+    context 'when target is an array' do
+      before do
+        subject.use A
+        subject.use B
+      end
+
+      it 'inserts before the first target' do
+        subject.before [ A, B ], C
+        expect(stack).to eq [ C, A, B ]
+      end
+
+      it 'ignores missing targets' do
+        subject.before [ B, Meddler ], C
+        expect(stack).to eq [ A, C, B ]
+      end
+
+      it 'handles nil targets' do
+        subject.before [ nil, B ], C
+        expect(stack).to eq [ A, C, B ]
+      end
+
+      it 'handles an empty array' do
+        subject.before [], C
+        expect(stack).to eq [ C, A, B ]
+      end
+    end
   end
 
   describe '#empty?' do
@@ -277,11 +331,35 @@ describe Meddleware do
   end
 
   describe '#include?' do
-    it 'works' do
-      expect(subject.include?(A)).to be false
-
+    before do
       subject.use A
-      expect(subject.include?(A)).to be true
+    end
+
+    it 'finds existing middleware' do
+      is_expected.to include A
+    end
+
+    it 'handles missing middleware' do
+      is_expected.not_to include B
+    end
+
+    it 'handles nil' do
+      is_expected.not_to include nil
+    end
+
+    context 'with multiple targets' do
+      it 'requires all targets to exist' do
+        expect(subject.include?(A, B)).to be false
+      end
+
+      it 'works when all targets exist' do
+        subject.use B
+        expect(subject.include?(A, B)).to be true
+      end
+
+      it 'handles nil' do
+        expect(subject.include?(A, nil)).to be false
+      end
     end
   end
 
@@ -311,6 +389,23 @@ describe Meddleware do
       subject.remove(nil)
       expect(stack).to eq [ A, B, C ]
     end
+
+    context 'with multiple targets' do
+      it 'removes multiple middleware' do
+        subject.remove(A, B)
+        expect(stack).to eq [ C ]
+      end
+
+      it 'handles redundancy' do
+        subject.remove(A, A)
+        expect(stack).to eq [ B, C ]
+      end
+
+      it 'handles nil' do
+        subject.remove(A, nil)
+        expect(stack).to eq [ B, C ]
+      end
+    end
   end
 
   describe '#replace' do
@@ -378,7 +473,7 @@ describe Meddleware do
     it 'is a private method' do
       expect {
         subject.index
-      }.to raise_error(NoMethodError, /private/)
+      }.to raise_error(NoMethodError)
     end
   end
 end

data/spec/call_meddleware_spec.rb

@@ -2,6 +2,7 @@ describe 'Meddleware#call' do
   subject { Meddleware.new }
 
   let(:middleware) { Meddler.new }
+  ruby3 = RUBY_VERSION >= '3'
 
   it 'works with no block, no stack' do
     expect(subject.call).to be nil
@@ -18,8 +19,9 @@ describe 'Meddleware#call' do
   end
 
   it 'passes args through to block' do
-    subject.call(:abc, x: :yz) do |*args|
-      expect(args).to eq [ :abc, { x: :yz } ]
+    subject.call(:abc, x: :yz) do |*args, **kwargs|
+      expect(args).to eq [ :abc ]
+      expect(kwargs).to eq x: :yz
     end
   end
 
@@ -56,10 +58,10 @@ describe 'Meddleware#call' do
       subject.call {}
     end
 
-    it 'calls middleware with args and block' do
-      expect(middleware).to receive(:call) do |a, b, &block|
+    it 'calls middleware with args, kwargs, and block' do
+      expect(middleware).to receive(:call) do |a, b:, &block|
         expect(a).to be :a
-        expect(b).to eq({ b: :c })
+        expect(b).to eq(:c)
         expect(block).to be_a Proc
       end
 
@@ -80,8 +82,9 @@ describe 'Meddleware#call' do
       end
 
       it 'implicitly passes along original arguments' do
-        subject.call(:abc) do |arg|
-          expect(arg).to be :abc
+        subject.call(:abc, x: :yz) do |*args, **kwargs|
+          expect(args).to eq [ :abc ]
+          expect(kwargs).to eq x: :yz
         end
       end
     end
@@ -89,21 +92,23 @@ describe 'Meddleware#call' do
     context 'when middleware calls block with explicit arguments' do
       it 'can add arguments' do
         expect(middleware).to receive(:call) do |&block|
-          block.call(:abc)
+          block.call(:abc, x: :yz)
         end
 
-        subject.call do |arg|
-          expect(arg).to be :abc
+        subject.call do |*args, **kwargs|
+          expect(args).to eq [ :abc ]
+          expect(kwargs).to eq x: :yz
         end
       end
 
       it 'can override the arguments passed on' do
         expect(middleware).to receive(:call) do |&block|
-          block.call(:abc)
+          block.call(:abc, x: :z)
         end
 
-        subject.call(123) do |arg|
-          expect(arg).to be :abc
+        subject.call(123, x: :y) do |*args, **kwargs|
+          expect(args).to eq [ :abc ]
+          expect(kwargs).to eq x: :z
         end
       end
 
@@ -112,9 +117,9 @@ describe 'Meddleware#call' do
           block.call(nil)
         end
 
-        subject.call(:abc, :xyz) do |a, x|
-          expect(a).to be nil
-          expect(x).to be nil
+        subject.call(:abc, x: :yz) do |arg, **kwargs|
+          expect(arg).to be nil
+          expect(kwargs).to be_empty
         end
       end
     end
@@ -158,23 +163,25 @@ describe 'Meddleware#call' do
 
   context 'with a middleware instance and arguments' do
     before do
-      subject.use middleware, :abc
+      subject.use middleware, :abc, x: :yz
     end
 
     it 'curries the arguments' do
-      expect(middleware).to receive(:call) do |*args, &block|
-        expect(args).to eq([ :abc ])
+      expect(middleware).to receive(:call) do |*args, **kwargs, &block|
+        expect(args).to eq [ :abc ]
+        expect(kwargs).to eq x: :yz
       end
 
       subject.call
     end
 
-    it 'curries and appends extra arguments' do
-      expect(middleware).to receive(:call) do |*args, &block|
-        expect(args).to eq([ :abc, :xyz ])
+    it 'curries and appends extra arguments', if: ruby3 do
+      expect(middleware).to receive(:call) do |*args, **kwargs, &block|
+        expect(args).to eq [ :abc, :def ]
+        expect(kwargs).to eq x: :yz, y: :z
       end
 
-      subject.call(:xyz)
+      subject.call(:def, y: :z)
     end
 
     it 'curries and appends, without yielding implicitly' do

data/spec/{examples_spec.rb → readme/full_example_spec.rb}

@@ -1,4 +1,6 @@
 module MyList
+  # generate an array from 1 to n
+
   extend self
 
   def middleware(&block)
@@ -8,18 +10,24 @@ module MyList
   end
 
   def generate(n)
-    middleware.call(n) {|n| (1..n).to_a }
+    # invoke middleware chain
+    middleware.call(n) do |n|
+      # do the actual work of generating your results
+      (1..n).to_a
+    end
   end
 end
 
 class OneExtra
   def call(n)
+    # adds one to the argument being passed in
     yield(n + 1)
   end
 end
 
 class Doubler
   def call(*)
+    # modifies the results by doubles each value
     yield.map {|x| x * 2 }
   end
 end
@@ -37,13 +45,16 @@ describe MyList do
     end
   end
 
+  after { MyList.middleware.clear }
+
   it 'calls middleware chain and generates a list' do
-    res = nil
+    res = MyList.generate(2)
+    expect(res).to eq [ 2, 4, 6 ]
+  end
 
+  it 'logs to stdout' do
     expect {
-      res = MyList.generate(2)
+      MyList.generate(2)
     }.to output("n starts as 2\nn ends as 3\n").to_stdout
-
-    expect(res).to eq [ 2, 4, 6 ]
   end
 end

data/spec/readme/usage_spec.rb

@@ -0,0 +1,47 @@
+require 'meddleware'
+
+# lib/mywidget.rb
+class MyWidget
+  def self.middleware(&block)
+    (@middleware ||= Meddleware.new).tap do
+      @middleware.instance_eval(&block) if block_given?
+    end
+  end
+
+  def do_the_thing
+    # invoke middleware chain
+    MyWidget.middleware.call do
+      # do your thing
+    end
+  end
+end
+
+MyMiddleware = proc {}
+
+# config/initializers/mywidget.rb
+MyWidget.middleware do
+  # add a logger
+  use { puts "before the thing" }
+
+  # add another middleware
+  use MyMiddleware
+end
+
+
+# use it from whereever
+# MyWidget.new.do_the_thing
+
+
+describe MyWidget do
+  it 'adds middleware to the framework' do
+    expect(MyWidget.middleware).to include(MyMiddleware)
+  end
+
+  it 'calls each middleware' do
+    expect(MyMiddleware).to receive(:call)
+
+    expect {
+      MyWidget.new.do_the_thing
+    }.to output("before the thing\n").to_stdout
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meddleware
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-05 00:00:00.000000000 Z
+date: 2021-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -87,11 +87,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/meddleware.rb
+- lib/meddleware/v2_5.rb
 - lib/meddleware/version.rb
 - spec/build_meddleware_spec.rb
 - spec/call_meddleware_chain_spec.rb
 - spec/call_meddleware_spec.rb
-- spec/examples_spec.rb
+- spec/readme/full_example_spec.rb
+- spec/readme/usage_spec.rb
 homepage: https://github.com/dpep/meddleware_rb
 licenses:
 - MIT
@@ -104,7 +106,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -117,6 +119,7 @@ specification_version: 4
 summary: Meddleware
 test_files:
 - spec/call_meddleware_spec.rb
+- spec/readme/usage_spec.rb
+- spec/readme/full_example_spec.rb
 - spec/call_meddleware_chain_spec.rb
 - spec/build_meddleware_spec.rb
-- spec/examples_spec.rb