meddleware 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bfe09bf6e8d403864543e0c74fea482608b78f31c83b32a6cca71ad1d8a3973
-  data.tar.gz: 93c888f10763f70779e9a834249e475f6eab18db3f2eacf9bd1442cb87f155d4
+  metadata.gz: 0c9a407cd470f194fda6286e743513706d094408be53bd75a31ebd14eef97fa2
+  data.tar.gz: 57243177c0047d94f58ca39eb3f9ceb6b9cdcb37aa204be3f2c511a934905e68
 SHA512:
-  metadata.gz: abaee8a6faafe5ed08d04d9a5166efedbf3e9cc51de2fc3bd1608ba57496e38676860b18bc44ab4a8dfc4030709fc287c84cfaa5001be7a391be7f5f09f4b736
-  data.tar.gz: 5222b652ae8a45723d4b20798d4c852d7b8a0e24a1449531c0c8fc96a3c3fa3a265e4bbe8bec3e81f1958a77112fd189f8a75b9bce2f66f3c4c8e5ae8770dac3
+  metadata.gz: 52816fdea29cea1af9a32ce346079686fe75ced2ac34d4bf972afe174e7d74a7bd62cd1e0bac6aab6433eb3373c66772d373ed17778ee251857625e1d7368fde
+  data.tar.gz: e4eb77b1748be5c025b3be3bf3c049ed167e7cd7624deb1ef980542667b4eb556a60c40ee911ac805f2aaa7de01a0c199129f45edc3b6701dd589bb23130434f

data/CHANGELOG.md

@@ -0,0 +1,36 @@
+###  v0.4.0  (2024-04-05)
+- drop ruby 2.7
+- gem constraints
+- simplify codecov
+- drop rake
+- test coverage
+
+###  v0.3.0  (2022-10-11)
+- extendable
+- drop ruby 2.5 (#4)
+- remove rake
+
+###  v0.2.0  (2021-09-14)
+- ruby 3 compatibility
+- usage spec
+- fix tests
+- simplify: move dedup functionality out of build method
+- array support
+
+###  v0.1.0  (2021-04-05)
+- spec examples
+- Update README.md
+- test coverage
+- bugs and tests
+- Meddleware.replace
+- proc support
+- validation and currying
+- test coverage
+- support instances and procs
+- gemfile cleanup
+- fix github actions
+- add specs, clean up
+- thanks
+
+###  v0.0.1  (2021-03-31)
+- skeleton

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    meddleware (0.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.1.3)
+    diff-lcs (1.5.1)
+    docile (1.4.0)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug (>= 11)
+  meddleware!
+  rspec (>= 3.13)
+  simplecov (>= 0.22)
+
+BUNDLED WITH
+   2.5.7

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Daniel Pepper
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,145 @@
+Meddleware
+======
+![Gem](https://img.shields.io/gem/dt/meddleware?style=plastic)
+[![codecov](https://codecov.io/gh/dpep/meddleware_rb/branch/main/graph/badge.svg)](https://codecov.io/gh/dpep/meddleware_rb)
+
+
+A middleware framework to make meddling easy.  Middleware is a popular pattern from Rack and Rails, which provides callers a way to execute code before and after yours.  This gives callers the ability to modify parameters or results, conditionally skip execution, and log activity without the need to monkey patch or subclass.
+
+
+```ruby
+require 'meddleware'
+
+# lib/mywidget.rb
+class MyWidget
+  extend Meddleware
+
+  def do_the_thing
+    # invoke middleware chain
+    middleware.call do
+      # do your thing
+      ...
+    end
+  end
+end
+
+# 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
+```
+
+
+## Usage
+Extend your class with Meddleware to add a `middleware` method.  Or use `include` to give each instance its own, individual middleware.
+
+```ruby
+class MyWidget
+  extend Meddleware
+end
+
+MyWidget.middleware
+```
+
+Then wrap your class's functionality so it will get executed along with the all the registered middleware.
+
+```ruby
+class MyWidget
+  extend Meddleware
+
+  def do_the_thing
+    # invoke middleware chain
+    middleware.call(*args) do
+      # do your thing
+      ...
+    end
+  end
+end
+```
+
+
+See [documentation](https://github.com/dpep/meddleware_rb/wiki/DSL) for full DSL.
+
+
+----
+## Full Example
+```ruby
+# lib/mylist.rb
+module MyList
+  extend Meddleware
+
+  # generate an array from 1 to n
+  def self.generate(n)
+    # invoke middleware chain
+    middleware.call(n) do |n|
+      # do the actual work of generating your results 
+      (1..n).to_a
+    end
+  end
+end
+
+# app/initializers/mylist.rb
+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
+
+MyList.middleware do
+  use OneExtra
+  use Doubler
+
+  # loggers
+  prepend {|x| puts "n starts as #{x}" }
+  append  {|x| puts "n ends as #{x}" }
+end
+
+
+# use it
+> MyList.generate(2)
+
+# would normally output [ 1, 2 ]
+# but with middleware:
+
+n starts as 2
+n ends as 3
+=> [2, 4, 6]
+```
+
+----
+## Contributing
+
+Yes please  :)
+
+1. Fork it
+1. Create your feature branch (`git checkout -b my-feature`)
+1. Ensure the tests pass (`bundle exec rspec`)
+1. Commit your changes (`git commit -am 'awesome new feature'`)
+1. Push your branch (`git push origin my-feature`)
+1. Create a Pull Request
+
+
+----
+### Inspired by / Thanks to
+
+[@mitchellh](https://github.com/mitchellh) + [middleware](https://github.com/mitchellh/middleware/tree/master/lib/middleware)
+
+[@mperham](https://github.com/mperham) + [Sidekiq](https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/middleware/chain.rb)
+
+[Rails](https://github.com/rails/rails/blob/main/actionpack/lib/action_dispatch/middleware/stack.rb)

data/lib/meddleware/stack.rb

@@ -0,0 +1,187 @@
+module Meddleware
+  class Stack
+    def initialize(&block)
+      instance_eval(&block) if block_given?
+    end
+
+    def use(*args, **kwargs, &block)
+      entry = create_entry(args, kwargs, block)
+      remove(entry[0])
+      stack << entry
+      self
+    end
+    alias append use
+
+    def prepend(*args, **kwargs, &block)
+      entry = create_entry(args, kwargs, block)
+      remove(entry[0])
+      stack.insert(0, entry)
+      self
+    end
+
+    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, *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)
+      klass.all? {|x| index(x) }
+    end
+
+    def remove(*klass)
+      stack.reject! { |entry| klass.include?(entry[0]) }
+      self
+    end
+
+    def replace(old_klass, *args, **kwargs, &block)
+      entry = create_entry(args, kwargs, block)
+      remove(entry[0])
+
+      i = index(old_klass)
+
+      unless i
+        raise RuntimeError, "middleware not present: #{old_klass}"
+      end
+
+      stack[i] = entry
+      self
+    end
+
+    def count
+      stack.count
+    end
+    alias size count
+
+    def clear
+      stack.clear
+    end
+
+    def empty?
+      stack.empty?
+    end
+
+    def call(*args, **kwargs)
+      chain = build_chain
+      default_args = args
+      default_kwargs = kwargs
+
+      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, **kwargs) if block_given?
+        else
+          middleware = chain.shift
+
+          if middleware.is_a?(Proc) && !middleware.lambda?
+            middleware.call(*args, **kwargs)
+
+            # implicit yield
+            traverse.call(*args, **kwargs)
+          else
+            middleware.call(*args, **kwargs, &traverse)
+          end
+        end
+      end
+
+      traverse.call(*args, **kwargs)
+    end
+
+
+    protected
+
+    def stack
+      @stack ||= []
+    end
+
+    def index(klass)
+      stack.index {|entry| entry[0] == klass }
+    end
+
+    def create_entry(args, kwargs, block)
+      klass, *args = args
+
+      if [ klass, block ].none?
+        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, kwargs, block ].compact
+      else
+        [ block ]
+      end
+    end
+
+    def build_chain
+      # build the middleware stack
+      stack.map do |klass, args, kwargs, block|
+        if klass.is_a? Class
+          klass.new(*args, **kwargs, &block)
+        else
+          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, **more_kwargs, &block) do
+              klass.call(
+                *(args + more_args),
+                **kwargs.merge(more_kwargs),
+                &block
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/meddleware/version.rb

@@ -1,3 +1,3 @@
-class Meddleware
-  VERSION = "0.2.0"
+module Meddleware
+  VERSION = "0.4.0"
 end

data/lib/meddleware.rb

@@ -1,192 +1,29 @@
+require 'meddleware/stack'
 require 'meddleware/version'
 
-class Meddleware
-  def initialize(&block)
-    instance_eval(&block) if block_given?
-  end
-
-  def use(*args, **kwargs, &block)
-    entry = create_entry(args, kwargs, block)
-    remove(entry[0])
-    stack << entry
-    self
-  end
-  alias append use
-
-  def prepend(*args, **kwargs, &block)
-    entry = create_entry(args, kwargs, block)
-    remove(entry[0])
-    stack.insert(0, entry)
-    self
-  end
-
-  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, *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)
-    klass.all? {|x| index(x) }
-  end
-
-  def remove(*klass)
-    stack.reject! { |entry| klass.include?(entry[0]) }
-    self
-  end
-
-  def replace(old_klass, *args, **kwargs, &block)
-    entry = create_entry(args, kwargs, block)
-    remove(entry[0])
-
-    i = index(old_klass)
-
-    unless i
-      raise RuntimeError, "middleware not present: #{old_klass}"
-    end
-
-    stack[i] = entry
-    self
-  end
-
-  def count
-    stack.count
-  end
-  alias size count
-
-  def clear
-    stack.clear
-  end
-
-  def empty?
-    stack.empty?
-  end
-
-  def call(*args, **kwargs)
-    chain = build_chain
-    default_args = args
-    default_kwargs = kwargs
-
-    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, **kwargs) if block_given?
-      else
-        middleware = chain.shift
-
-        if middleware.is_a?(Proc) && !middleware.lambda?
-          middleware.call(*args, **kwargs)
-
-          # implicit yield
-          traverse.call(*args, **kwargs)
-        else
-          middleware.call(*args, **kwargs, &traverse)
-        end
-      end
+module Meddleware
+  def middleware(&block)
+    (@middleware ||= Meddleware::Stack.new).tap do
+      @middleware.instance_eval(&block) if block_given?
     end
-
-    traverse.call(*args, **kwargs)
-  end
-
-
-  protected
-
-  def stack
-    @stack ||= []
-  end
-
-  def index(klass)
-    stack.index {|entry| entry[0] == klass }
   end
 
-  def create_entry(args, kwargs, block)
-    klass, *args = args
-
-    if [ klass, block ].compact.empty?
-      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
+  private
 
-        unless block.nil?
-          raise ArgumentError, 'can not supply middleware instance and block'
+  def self.extended(base)
+    unless base.instance_methods.include?(:middleware)
+      base.class_eval do
+        def middleware
+          self.class.middleware
         end
       end
-
-      [ klass, args, kwargs, block ].compact
-    else
-      [ block ]
     end
   end
 
-  def build_chain
-    # build the middleware stack
-    stack.map do |klass, args, kwargs, block|
-      if klass.is_a? Class
-        klass.new(*args, **kwargs, &block)
-      else
-        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, **more_kwargs, &block) do
-            klass.call(
-              *(args + more_args),
-              **kwargs.merge(more_kwargs),
-              &block
-            )
-          end
-        end
-      end
-    end
-  end
+  def self.append_features(base)
+    # remove instance helper from `extended`
+    base.remove_method(:middleware) if base.instance_methods(false).include?(:middleware)
 
-  if RUBY_VERSION < '3'
-    require 'meddleware/v2_5'
-    prepend Meddleware::V2_5
+    super
   end
 end

data/meddleware.gemspec

@@ -0,0 +1,19 @@
+require_relative "lib/meddleware/version"
+package = Meddleware
+
+Gem::Specification.new do |s|
+  s.name        = File.basename(__FILE__).split(".")[0]
+  s.version     = package.const_get 'VERSION'
+  s.authors     = ['Daniel Pepper']
+  s.summary     = package.to_s
+  s.description = 'A middleware framework to make meddling easy.'
+  s.homepage    = "https://github.com/dpep/meddleware_rb"
+  s.license     = 'MIT'
+  s.files       = `git ls-files * ':!:spec'`.split("\n")
+
+  s.required_ruby_version = '>= 3'
+
+  s.add_development_dependency 'byebug', '>= 11'
+  s.add_development_dependency 'rspec', '>= 3.13'
+  s.add_development_dependency 'simplecov', '>= 0.22'
+end