meddleware 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af421278a6c18f72f28e6ad86e214bcbaab0e77cc9e77a58db94493045be3bf7
-  data.tar.gz: 912d29bc7b291ad682cdf7aadcfd05631aec896cc578957048f233478f5cbb2f
+  metadata.gz: 453a4fea42903735f1b7e502f5fb5ba323ecfd1240db7d476453dabd0e773f8d
+  data.tar.gz: c459598e2a9145a7ad8a4128cefc5de8ed3a018db28e1cf95a24a26b15b42883
 SHA512:
-  metadata.gz: 0b792cee28734eeea2b632d17e45ec139b92eaeb8dc8e5d9421dd27ebf54f62dbbf63453b526d50c483406f502dfff696785ea37a31ecbc988a295333b5c728f
-  data.tar.gz: b854aa5aa9dee535ea746ac333dcbfd222a0a11dbc36d6262e96fe2930ef8827a5c93c08afb41d38564b79079d43d03b2225d8e0b87cbe7ce63c1ac5b1705965
+  metadata.gz: 94db19316854023dece52b027bd87f0c423936c3ccf4fba424b85eaa798672aa936820ecb0b5e427c5832c29fe7deb6dce876563c70c3869b15b1b137d26b511
+  data.tar.gz: 57188689d33ca8a987e4cdcde3792da430b86946c6c0ec99ace62b6e7be05c9658eacbc83f6e3cc26c20d3c8e06a47ef53fa4937919d7d4c1e49a556469cc0c3

data/lib/meddleware.rb

@@ -1,77 +1,158 @@
 require 'meddleware/version'
 
 class Meddleware
-  include Enumerable
-
-  def initialize
+  def initialize(&block)
     instance_eval(&block) if block_given?
   end
 
-  def each(&block)
-    stack.each(&block)
+  def use(*klass_and_args, &block)
+    entry = create_entry(klass_and_args, block)
+    stack << entry
+    self
   end
+  alias append use
 
-  def index(klass)
-    stack.index {|entry| entry.klass == klass }
+  def prepend(*klass_and_args, &block)
+    entry = create_entry(klass_and_args, block)
+    stack.insert(0, entry)
+    self
   end
 
-  def remove(klass)
-    stack.reject! { |entry| entry.klass == klass }
+  def after(after_klass, *klass_and_args, &block)
+    entry = create_entry(klass_and_args, block)
+    i = index(after_klass) || count - 1
+    stack.insert(i + 1, entry)
+    self
   end
 
-  def use(klass, *args)
-    remove(klass)
-    stack << Entry.new(klass, args)
+  def before(before_klass, *klass_and_args, &block)
+    entry = create_entry(klass_and_args, block)
+    i = index(before_klass) || 0
+    stack.insert(i, entry)
+    self
   end
-  alias append use
 
-  def prepend(klass, *args)
-    remove(klass)
-    stack.insert(0, Entry.new(klass, args))
+  def include?(klass)
+    !!index(klass)
   end
 
-  def after(after_klass, klass, *args)
-    remove(klass)
-    i = index(after_klass) || count - 1
-    stack.insert(i + 1, Entry.new(klass, args))
+  def remove(klass)
+    stack.reject! { |entry| entry[0] == klass }
+    self
   end
 
-  def before(before_klass, klass, *args)
-    remove(klass)
-    i = index(before_klass) || 0
-    stack.insert(i, Entry.new(klass, args))
+  def replace(old_klass, *klass_and_args, &block)
+    entry = create_entry(klass_and_args, block)
+    i = index(old_klass)
+
+    unless i
+      raise RuntimeError, "middleware not present: #{old_klass}"
+    end
+
+    stack[i] = entry
+    self
   end
 
-  def empty?
-    stack.empty?
+  def count
+    stack.count
   end
+  alias size count
 
   def clear
     stack.clear
   end
 
-  def call(*args, &block)
-    chain = map(&:build)
-    traverse = proc do |*updated_args|
-      args = updated_args unless updated_args.empty?
+  def empty?
+    stack.empty?
+  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
+        yield(*args) if block_given?
       else
-        chain.shift.call(*args, &traverse)
+        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 stack
     @stack ||= []
   end
 
-  Entry = Struct.new(:klass, :args) do
-    def build
-      klass.new(*args)
+  def index(klass)
+    stack.index {|entry| entry[0] == klass }
+  end
+
+  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
+
+    # dedup
+    remove(klass || block)
+
+    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 ]
+    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

data/lib/meddleware/version.rb

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

data/spec/build_meddleware_spec.rb

@@ -0,0 +1,384 @@
+A = Class.new(Meddler)
+B = Class.new(Meddler)
+C = Class.new(Meddler)
+
+
+describe Meddleware do
+  subject { described_class.new }
+
+  def stack
+    subject.send(:build_chain).map &:class
+  end
+
+  shared_examples 'a middleware adder method' do |name|
+    let(:function) do
+      subject.method(name).yield_self do |fn|
+        if fn.arity < -1
+          # needs prefix arg, eg. :before/:after
+          proc {|*args, &block| fn.call(nil, *args, &block) }
+        else
+          fn
+        end
+      end
+    end
+
+    it 'adds middleware to the stack' do
+      function.call(A)
+      expect(stack).to eq [ A ]
+    end
+
+    it 'does not add duplicates' do
+      3.times { function.call(A) }
+      expect(stack).to eq [ A ]
+    end
+
+    it 'returns self' do
+      expect(function.call(A)).to be subject
+    end
+
+    it 'is idempotent' do
+      subject.use A
+      function.call(B)
+      res = stack
+
+      function.call(B)
+      expect(stack).to eq res
+    end
+
+    context 'with arguments' do
+      after { subject.send :build_chain }
+
+      it 'accepts an argument' do
+        expect(A).to receive(:new).with(:abc)
+        function.call(A, :abc)
+      end
+
+      it 'accepts multiple arguments' do
+        expect(A).to receive(:new).with(:abc, :xyz)
+        function.call(A, :abc, :xyz)
+      end
+
+      it 'accepts kwargs' do
+        expect(A).to receive(:new).with(a: 1, b: 2)
+        function.call(A, a: 1, b: 2)
+      end
+
+      it 'works with all forms of kwargs' do
+        expect(A).to receive(:new).with(a: 1, b: 2)
+        function.call(A, { a: 1, b: 2 })
+
+        expect(B).to receive(:new).with({ a: 1, b: 2 })
+        function.call(B, { a: 1, b: 2 })
+
+        expect(C).to receive(:new).with({ a: 1, b: 2 })
+        function.call(C, a: 1, b: 2)
+      end
+
+      it 'works with both args and kwargs' do
+        expect(A).to receive(:new).with(:abc, a: 1, b: 2)
+        function.call(A, :abc, a: 1, b: 2)
+      end
+    end
+
+    context 'when middleware is an instance' do
+      it 'adds middleware to the stack' do
+        function.call(A.new)
+        expect(stack).to eq [ A ]
+      end
+
+      it 'will add multiple instances of the same class' do
+        function.call(A.new)
+        function.call(A.new)
+        expect(stack).to eq [ A, A ]
+      end
+    end
+
+    context 'when middleware is a block' do
+      it 'accepts procs' do
+        function.call(Proc.new {})
+        expect(stack).to eq [ Proc ]
+      end
+
+      it 'accepts lambdas' do
+        function.call(-> {})
+        expect(stack).to eq [ Proc ]
+      end
+
+      it 'accepts inline blocks' do
+        function.call {}
+        expect(stack).to eq [ Proc ]
+      end
+    end
+
+    context 'when middleware is invalid' do
+      it 'rejects classes that do not implement `.call`' do
+        expect {
+          function.call(Class.new)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'rejects instances that do not respond to `.call`' do
+        expect {
+          function.call(123)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'fails when both instance and block are passed' do
+        expect {
+          function.call(A.new) {}
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'rejects nil' do
+        expect {
+          function.call(nil)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#use' do
+    it_behaves_like 'a middleware adder method', :use
+
+    it 'appends middleware in order' do
+      subject.use A
+      subject.use B
+      expect(stack).to eq [ A, B ]
+    end
+
+    it 'reorders duplicates' do
+      subject.use A
+      subject.use B
+      subject.use A
+      expect(stack).to eq [ B, A ]
+    end
+  end
+
+  describe '#prepend' do
+    it_behaves_like 'a middleware adder method', :prepend
+
+    it 'prepends middleware in order' do
+      subject.prepend A
+      subject.prepend B
+      expect(stack).to eq [ B, A ]
+    end
+
+    it 'reorders duplicates' do
+      subject.prepend A
+      subject.prepend B
+      subject.prepend A
+      expect(stack).to eq [ A, B ]
+    end
+  end
+
+  describe '#after' do
+    it_behaves_like 'a middleware adder method', :after
+
+    it 'adds middleware where specified' do
+      subject.use A
+      subject.use B
+      subject.after A, C
+      expect(stack).to eq [ A, C, B ]
+    end
+
+    it 'maintans order for duplicates' do
+      subject.use A
+      subject.use B
+      subject.after A, C
+      subject.after A, C
+      expect(stack).to eq [ A, C, B ]
+    end
+
+    it 'works when target is missing' do
+      subject.use A
+      subject.after B, C
+      expect(stack).to eq [ A, C ]
+    end
+
+    it 'works when target is nil' do
+      subject.use A
+      subject.after nil, C
+      expect(stack).to eq [ A, C ]
+    end
+  end
+
+  describe '#before' do
+    it_behaves_like 'a middleware adder method', :before
+
+    it 'adds middleware where specified' do
+      subject.use A
+      subject.use B
+      subject.before B, C
+      expect(stack).to eq [ A, C, B ]
+    end
+
+    it 'maintans order for duplicates' do
+      subject.use A
+      subject.use B
+      subject.before B, C
+      subject.before B, C
+      expect(stack).to eq [ A, C, B ]
+    end
+
+    it 'works when target is missing' do
+      subject.use A
+      subject.before B, C
+      expect(stack).to eq [ C, A ]
+    end
+
+    it 'works when target is nil' do
+      subject.use A
+      subject.before nil, C
+      expect(stack).to eq [ C, A ]
+    end
+  end
+
+  describe '#empty?' do
+    it 'works with empty middleware' do
+      expect(subject).to be_empty
+      expect(subject.empty?).to be true
+      expect(stack.empty?).to be true
+    end
+
+    it 'works with middleware' do
+      subject.use A
+      expect(subject).not_to be_empty
+      expect(subject.empty?).to be false
+      expect(stack.empty?).to be false
+    end
+  end
+
+  describe '#clear' do
+    it 'works' do
+      subject.use A
+      subject.clear
+      expect(subject).to be_empty
+    end
+
+    it 'works with an empty stack' do
+      subject.clear
+      expect(subject).to be_empty
+    end
+  end
+
+  describe '#count' do
+    it 'works' do
+      expect(subject.count).to be 0
+
+      subject.use A
+      expect(subject.count).to be 1
+
+      subject.use B
+      expect(subject.count).to be 2
+
+      subject.remove B
+      expect(subject.count).to be 1
+    end
+  end
+
+  describe '#include?' do
+    it 'works' do
+      expect(subject.include?(A)).to be false
+
+      subject.use A
+      expect(subject.include?(A)).to be true
+    end
+  end
+
+  describe '#remove' do
+    before do
+      subject.use A
+      subject.use B
+      subject.use C
+      expect(stack).to eq [ A, B, C ]
+    end
+
+    it 'removes middleware' do
+      subject.remove(B)
+      expect(stack).to eq [ A, C ]
+      subject.remove(A)
+      expect(stack).to eq [ C ]
+      subject.remove(C)
+      expect(subject).to be_empty
+    end
+
+    it 'is idempotent' do
+      3.times { subject.remove(A) }
+      expect(stack).to eq [ B, C ]
+    end
+
+    it 'works with nil' do
+      subject.remove(nil)
+      expect(stack).to eq [ A, B, C ]
+    end
+  end
+
+  describe '#replace' do
+    before do
+      subject.use A
+      subject.use B
+
+      expect(stack).to eq [ A, B ]
+    end
+
+    it 'replaces middleware' do
+      subject.replace(A, C)
+      expect(stack).to eq [ C, B ]
+    end
+
+    it 'works with middleware instances' do
+      instance = A.new
+      subject.replace(A, instance)
+
+      expect(subject).to include instance
+      expect(subject).not_to include A
+
+      subject.replace(instance, B)
+      expect(stack).to eq [ B ]
+    end
+
+    it 'fails when target middleware is missing' do
+      expect {
+        subject.replace(C, C)
+      }.to raise_error(RuntimeError)
+    end
+
+    it 'fails when middleware is invalid' do
+      expect {
+        subject.replace(A, nil)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '.new' do
+    it 'supports block mode' do
+      instance = described_class.new do
+        use A
+        prepend B
+      end
+
+      expect(instance).to include A
+      expect(instance).to include B
+    end
+  end
+
+  describe '#index' do
+    before do
+      subject.use A
+      subject.use B
+    end
+
+    it do
+      expect(subject.send(:index, A)).to be 0
+      expect(subject.send(:index, B)).to be 1
+      expect(subject.send(:index, C)).to be nil
+      expect(subject.send(:index, nil)).to be nil
+    end
+
+    it 'is a private method' do
+      expect {
+        subject.index
+      }.to raise_error(NoMethodError, /private/)
+    end
+  end
+end

data/spec/call_meddleware_chain_spec.rb

@@ -0,0 +1,74 @@
+describe 'Meddleware#call' do
+  subject { Meddleware.new }
+
+  let(:middleware_one) { Meddler.new }
+  let(:middleware_two) { Meddler.new }
+
+  before do
+    subject.use middleware_one
+    subject.use middleware_two
+  end
+
+  it 'calls the whole chain' do
+    expect(middleware_one).to receive(:call).and_yield
+    expect(middleware_two).to receive(:call).and_yield
+
+    expect {|b| subject.call(&b) }.to yield_control
+  end
+
+  it 'stops propagation if a middleware does not yield' do
+    expect(middleware_one).to receive(:call).and_yield
+    expect(middleware_two).to receive(:call)
+
+    expect {|b| subject.call(&b) }.not_to yield_control
+  end
+
+  it 'recurses' do
+    order = []
+
+    expect(middleware_one).to receive(:call) do |&block|
+      order << 1
+      block.call
+      order << 5
+    end
+
+    expect(middleware_two).to receive(:call) do |&block|
+      order << 2
+      block.call
+      order << 4
+    end
+
+    subject.call { order << 3 }
+    expect(order).to eq((1..5).to_a)
+  end
+
+  context 'when arguments are altered' do
+    before do
+      expect(middleware_one).to receive(:call) do |x, &block|
+        block.call(x * 2)
+      end
+    end
+
+    it 'propagates them' do
+      expect(middleware_two).to receive(:call) do |x, &block|
+        expect(x).to be 2
+        block.call(x * 3)
+      end
+
+      subject.call(1) do |x|
+        expect(x).to be 6
+      end
+    end
+
+    it 'propagates them as default arguments' do
+      expect(middleware_two).to receive(:call) do |x, &block|
+        expect(x).to be 2
+        block.call
+      end
+
+      subject.call(1) do |x|
+        expect(x).to be 2
+      end
+    end
+  end
+end

data/spec/call_meddleware_spec.rb

@@ -0,0 +1,259 @@
+describe 'Meddleware#call' do
+  subject { Meddleware.new }
+
+  let(:middleware) { Meddler.new }
+
+  it 'works with no block, no stack' do
+    expect(subject.call).to be nil
+  end
+
+  it 'returns the blocks value' do
+    res = subject.call { 123 }
+    expect(res).to be 123
+  end
+
+  it 'works with args' do
+    res = subject.call(:abc) { 123 }
+    expect(res).to be 123
+  end
+
+  it 'passes args through to block' do
+    subject.call(:abc, x: :yz) do |*args|
+      expect(args).to eq [ :abc, { x: :yz } ]
+    end
+  end
+
+  context 'with a middleware class' do
+    it 'instantiates and calls the middleware' do
+      expect(Meddler).to receive(:new).and_return(middleware)
+      expect(middleware).to receive(:call)
+
+      subject.use Meddler
+      subject.call
+    end
+  end
+
+  context 'with a middleware instance' do
+    before do
+      subject.use middleware
+    end
+
+    it 'calls middleware' do
+      expect(middleware).to receive(:call)
+      subject.call
+    end
+
+    it 'calls middleware with args' do
+      expect(middleware).to receive(:call).with(:abc)
+      subject.call(:abc)
+    end
+
+    it 'calls middleware with block' do
+      expect(middleware).to receive(:call) do |&block|
+        expect(block).to be_a Proc
+      end
+
+      subject.call {}
+    end
+
+    it 'calls middleware with args and block' do
+      expect(middleware).to receive(:call) do |a, b, &block|
+        expect(a).to be :a
+        expect(b).to eq({ b: :c })
+        expect(block).to be_a Proc
+      end
+
+      subject.call(:a, b: :c) {}
+    end
+
+    it 'can return a value' do
+      expect(middleware).to receive(:call) { 123 }
+
+      expect(subject.call).to be 123
+    end
+
+    context 'when middleware calls block without explicit arguments' do
+      before do
+        expect(middleware).to receive(:call) do |&block|
+          block.call
+        end
+      end
+
+      it 'implicitly passes along original arguments' do
+        subject.call(:abc) do |arg|
+          expect(arg).to be :abc
+        end
+      end
+    end
+
+    context 'when middleware calls block with explicit arguments' do
+      it 'can add arguments' do
+        expect(middleware).to receive(:call) do |&block|
+          block.call(:abc)
+        end
+
+        subject.call do |arg|
+          expect(arg).to be :abc
+        end
+      end
+
+      it 'can override the arguments passed on' do
+        expect(middleware).to receive(:call) do |&block|
+          block.call(:abc)
+        end
+
+        subject.call(123) do |arg|
+          expect(arg).to be :abc
+        end
+      end
+
+      it 'can remove arguments' do
+        expect(middleware).to receive(:call) do |&block|
+          block.call(nil)
+        end
+
+        subject.call(:abc, :xyz) do |a, x|
+          expect(a).to be nil
+          expect(x).to be nil
+        end
+      end
+    end
+
+    context 'when middleware meddles with pass-by-ref arguments' do
+      before do
+        expect(middleware).to receive(:call) do |arg, &block|
+          arg[:abc] = 123
+          block.call
+        end
+      end
+
+      it 'alters the value for the block' do
+        subject.call({}) do |info|
+          expect(info).to eq({ abc: 123 })
+        end
+      end
+
+      it 'alters the value for the caller' do
+        info = {}
+        subject.call(info)
+        expect(info).to eq({ abc: 123 })
+      end
+    end
+
+    context 'when middleware meddles with pass-by-value arguments' do
+      before do
+        expect(middleware).to receive(:call) do |arg, &block|
+          arg = 123
+          block.call
+        end
+      end
+
+      it 'has no effect...unfortunately' do
+        subject.call(:abc) do |arg|
+          expect(arg).to be :abc
+        end
+      end
+    end
+  end
+
+  context 'with a middleware instance and arguments' do
+    before do
+      subject.use middleware, :abc
+    end
+
+    it 'curries the arguments' do
+      expect(middleware).to receive(:call) do |*args, &block|
+        expect(args).to eq([ :abc ])
+      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 ])
+      end
+
+      subject.call(:xyz)
+    end
+
+    it 'curries and appends, without yielding implicitly' do
+      res = subject.call(:xyz) { 123 }
+      expect(res).to be nil
+      end
+
+    it 'curries and appends, and can yield explicitly' do
+      expect(middleware).to receive(:call) do |*args, &block|
+        block.call
+      end
+
+      res = subject.call(:xyz) { 123 }
+      expect(res).to be 123
+    end
+  end
+
+  context 'with a middleware Proc' do
+    it 'passes arguments to the Proc' do
+      fn = proc {|arg| expect(arg).to be :abc }
+      expect(fn).to receive(:call).and_call_original
+
+      subject.use fn
+      subject.call(:abc)
+    end
+
+    it 'curries arguments' do
+      fn = proc {|*args| expect(args).to eq [ :xyz, :abc ] }
+      expect(fn).to receive(:call).and_call_original
+
+      subject.use fn, :xyz
+      subject.call(:abc)
+    end
+
+    it 'can alter arguments' do
+      fn = proc {|data| data[:abc] = 123 }
+      subject.use fn
+
+      data = {}
+      subject.call(data)
+      expect(data).to eq({ abc: 123 })
+    end
+
+    it 'can not abort middleware chain...unfortunately' do
+      fn = proc { return }
+
+      subject.use fn
+      expect {
+        subject.call
+      }.to raise_error(LocalJumpError)
+    end
+
+    it 'calls yield implicitly' do
+      fn = proc {}
+      expect(fn).to receive(:call).and_call_original
+
+      subject.use fn
+      res = subject.call { 123 }
+      expect(res).to be 123
+    end
+  end
+
+  context 'with a middleware Lambda' do
+    it 'does not explicitly call yield' do
+      fn = ->{}
+      expect(fn).to receive(:call).and_call_original
+
+      subject.use fn
+      res = subject.call { 123 }
+      expect(res).to be nil
+    end
+
+    it 'does can explicitly yield' do
+      fn = ->(&block) { block.call }
+      expect(fn).to receive(:call).and_call_original
+
+      subject.use fn
+      res = subject.call { 123 }
+      expect(res).to be 123
+    end
+  end
+end

data/spec/examples_spec.rb

@@ -0,0 +1,49 @@
+module MyList
+  extend self
+
+  def middleware(&block)
+    (@middleware ||= Meddleware.new).tap do
+      @middleware.instance_eval(&block) if block_given?
+    end
+  end
+
+  def generate(n)
+    middleware.call(n) {|n| (1..n).to_a }
+  end
+end
+
+class OneExtra
+  def call(n)
+    yield(n + 1)
+  end
+end
+
+class Doubler
+  def call(*)
+    yield.map {|x| x * 2 }
+  end
+end
+
+
+describe MyList do
+  before do
+    MyList.middleware do
+      use OneExtra
+      use Doubler
+
+      # loggers
+      prepend {|x| puts "n starts as #{x}" }
+      append  {|x| puts "n ends as #{x}" }
+    end
+  end
+
+  it 'calls middleware chain and generates a list' do
+    res = nil
+
+    expect {
+      res = 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meddleware
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-01 00:00:00.000000000 Z
+date: 2021-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -80,7 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: work...within limits
+description: A middleware framework to make meddling easy.
 email:
 executables: []
 extensions: []
@@ -88,7 +88,10 @@ extra_rdoc_files: []
 files:
 - lib/meddleware.rb
 - lib/meddleware/version.rb
-- spec/meddleware_spec.rb
+- spec/build_meddleware_spec.rb
+- spec/call_meddleware_chain_spec.rb
+- spec/call_meddleware_spec.rb
+- spec/examples_spec.rb
 homepage: https://github.com/dpep/meddleware_rb
 licenses:
 - MIT
@@ -113,4 +116,7 @@ signing_key:
 specification_version: 4
 summary: Meddleware
 test_files:
-- spec/meddleware_spec.rb
+- spec/call_meddleware_spec.rb
+- spec/call_meddleware_chain_spec.rb
+- spec/build_meddleware_spec.rb
+- spec/examples_spec.rb

data/spec/meddleware_spec.rb

@@ -1,3 +0,0 @@
-describe Meddleware do
-
-end